@schemx/vue 0.1.20 → 0.1.21

package/dist/index.mjs

@@ -1,8 +1,4602 @@
-import { computed, provide, onUnmounted, inject, shallowRef, ref, onMounted, watchEffect, onScopeDispose, defineComponent, createVNode, toRef, h, createTextVNode, watch, openBlock, createElementBlock, normalizeClass, Fragment, renderList, unref, createBlock, createSlots, withCtx, renderSlot, mergeProps } from "vue";
+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";
-import { createRendererRegistry, createValidatorsRegistry, createForm, createField, createWatch, createEffect } from "@schemx/core";
-export * from "@schemx/core";
+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);
+var i = Symbol.for("preact-signals");
+function t() {
+  if (!(s > 1)) {
+    var i2, t2 = false;
+    !function() {
+      var i3 = c;
+      c = void 0;
+      while (void 0 !== i3) {
+        if (i3.S.v === i3.v) i3.S.i = i3.i;
+        i3 = i3.o;
+      }
+    }();
+    while (void 0 !== h) {
+      var n2 = h;
+      h = void 0;
+      v++;
+      while (void 0 !== n2) {
+        var r2 = n2.u;
+        n2.u = void 0;
+        n2.f &= -3;
+        if (!(8 & n2.f) && w(n2)) try {
+          n2.c();
+        } catch (n3) {
+          if (!t2) {
+            i2 = n3;
+            t2 = true;
+          }
+        }
+        n2 = r2;
+      }
+    }
+    v = 0;
+    s--;
+    if (t2) throw i2;
+  } else s--;
+}
+function n(i2) {
+  if (s > 0) return i2();
+  e = ++u;
+  s++;
+  try {
+    return i2();
+  } finally {
+    t();
+  }
+}
+var r = void 0;
+function o(i2) {
+  var t2 = r;
+  r = void 0;
+  try {
+    return i2();
+  } finally {
+    r = t2;
+  }
+}
+var h = void 0, s = 0, v = 0, u = 0, e = 0, c = void 0, d = 0;
+function a(i2) {
+  if (void 0 !== r) {
+    var t2 = i2.n;
+    if (void 0 === t2 || t2.t !== r) {
+      t2 = { i: 0, S: i2, p: r.s, n: void 0, t: r, e: void 0, x: void 0, r: t2 };
+      if (void 0 !== r.s) r.s.n = t2;
+      r.s = t2;
+      i2.n = t2;
+      if (32 & r.f) i2.S(t2);
+      return t2;
+    } else if (-1 === t2.i) {
+      t2.i = 0;
+      if (void 0 !== t2.n) {
+        t2.n.p = t2.p;
+        if (void 0 !== t2.p) t2.p.n = t2.n;
+        t2.p = r.s;
+        t2.n = void 0;
+        r.s.n = t2;
+        r.s = t2;
+      }
+      return t2;
+    }
+  }
+}
+function l(i2, t2) {
+  this.v = i2;
+  this.i = 0;
+  this.n = void 0;
+  this.t = void 0;
+  this.l = 0;
+  this.W = null == t2 ? void 0 : t2.watched;
+  this.Z = null == t2 ? void 0 : t2.unwatched;
+  this.name = null == t2 ? void 0 : t2.name;
+}
+l.prototype.brand = i;
+l.prototype.h = function() {
+  return true;
+};
+l.prototype.S = function(i2) {
+  var t2 = this, n2 = this.t;
+  if (n2 !== i2 && void 0 === i2.e) {
+    i2.x = n2;
+    this.t = i2;
+    if (void 0 !== n2) n2.e = i2;
+    else o(function() {
+      var i3;
+      null == (i3 = t2.W) || i3.call(t2);
+    });
+  }
+};
+l.prototype.U = function(i2) {
+  var t2 = this;
+  if (void 0 !== this.t) {
+    var n2 = i2.e, r2 = i2.x;
+    if (void 0 !== n2) {
+      n2.x = r2;
+      i2.e = void 0;
+    }
+    if (void 0 !== r2) {
+      r2.e = n2;
+      i2.x = void 0;
+    }
+    if (i2 === this.t) {
+      this.t = r2;
+      if (void 0 === r2) o(function() {
+        var i3;
+        null == (i3 = t2.Z) || i3.call(t2);
+      });
+    }
+  }
+};
+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;
+    }
+  }, { name: "sub" });
+};
+l.prototype.valueOf = function() {
+  return this.value;
+};
+l.prototype.toString = function() {
+  return this.value + "";
+};
+l.prototype.toJSON = function() {
+  return this.value;
+};
+l.prototype.peek = function() {
+  var i2 = this;
+  return o(function() {
+    return i2.value;
+  });
+};
+Object.defineProperty(l.prototype, "value", { get: function() {
+  var i2 = a(this);
+  if (void 0 !== i2) i2.i = this.i;
+  return this.v;
+}, set: function(i2) {
+  if (i2 !== this.v) {
+    if (v > 100) throw new Error("Cycle detected");
+    !function(i3) {
+      if (0 !== s && 0 === v) {
+        if (i3.l !== e) {
+          i3.l = e;
+          c = { S: i3, v: i3.v, i: i3.i, o: c };
+        }
+      }
+    }(this);
+    this.v = i2;
+    this.i++;
+    d++;
+    s++;
+    try {
+      for (var n2 = this.t; void 0 !== n2; n2 = n2.x) n2.t.N();
+    } finally {
+      t();
+    }
+  }
+} });
+function y(i2, t2) {
+  return new l(i2, t2);
+}
+function w(i2) {
+  for (var t2 = i2.s; void 0 !== t2; t2 = t2.n) if (t2.S.i !== t2.i || !t2.S.h() || t2.S.i !== t2.i) return true;
+  return false;
+}
+function _(i2) {
+  for (var t2 = i2.s; void 0 !== t2; t2 = t2.n) {
+    var n2 = t2.S.n;
+    if (void 0 !== n2) t2.r = n2;
+    t2.S.n = t2;
+    t2.i = -1;
+    if (void 0 === t2.n) {
+      i2.s = t2;
+      break;
+    }
+  }
+}
+function b(i2) {
+  var t2 = i2.s, n2 = void 0;
+  while (void 0 !== t2) {
+    var r2 = t2.p;
+    if (-1 === t2.i) {
+      t2.S.U(t2);
+      if (void 0 !== r2) r2.n = t2.n;
+      if (void 0 !== t2.n) t2.n.p = r2;
+    } else n2 = t2;
+    t2.S.n = t2.r;
+    if (void 0 !== t2.r) t2.r = void 0;
+    t2 = r2;
+  }
+  i2.s = n2;
+}
+function p(i2, t2) {
+  l.call(this, void 0);
+  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() {
+  this.f &= -3;
+  if (1 & this.f) return false;
+  if (32 == (36 & this.f)) return true;
+  this.f &= -5;
+  if (this.g === d) return true;
+  this.g = d;
+  this.f |= 1;
+  if (this.i > 0 && !w(this)) {
+    this.f &= -2;
+    return true;
+  }
+  var i2 = r;
+  try {
+    _(this);
+    r = this;
+    var t2 = this.x();
+    if (16 & this.f || this.v !== t2 || 0 === this.i) {
+      this.v = t2;
+      this.f &= -17;
+      this.i++;
+    }
+  } catch (i3) {
+    this.v = i3;
+    this.f |= 16;
+    this.i++;
+  }
+  r = i2;
+  b(this);
+  this.f &= -2;
+  return true;
+};
+p.prototype.S = function(i2) {
+  if (void 0 === this.t) {
+    this.f |= 36;
+    for (var t2 = this.s; void 0 !== t2; t2 = t2.n) t2.S.S(t2);
+  }
+  l.prototype.S.call(this, i2);
+};
+p.prototype.U = function(i2) {
+  if (void 0 !== this.t) {
+    l.prototype.U.call(this, i2);
+    if (void 0 === this.t) {
+      this.f &= -33;
+      for (var t2 = this.s; void 0 !== t2; t2 = t2.n) t2.S.U(t2);
+    }
+  }
+};
+p.prototype.N = function() {
+  if (!(2 & this.f)) {
+    this.f |= 6;
+    for (var i2 = this.t; void 0 !== i2; i2 = i2.x) i2.t.N();
+  }
+};
+Object.defineProperty(p.prototype, "value", { get: function() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  var i2 = a(this);
+  this.h();
+  if (void 0 !== i2) i2.i = this.i;
+  if (16 & this.f) throw this.v;
+  return this.v;
+} });
+function S(i2) {
+  var n2 = i2.m;
+  i2.m = void 0;
+  if ("function" == typeof n2) {
+    s++;
+    var o2 = r;
+    r = void 0;
+    try {
+      n2();
+    } catch (t2) {
+      i2.f &= -2;
+      i2.f |= 8;
+      m(i2);
+      throw t2;
+    } finally {
+      r = o2;
+      t();
+    }
+  }
+}
+function m(i2) {
+  for (var t2 = i2.s; void 0 !== t2; t2 = t2.n) t2.S.U(t2);
+  i2.x = void 0;
+  i2.s = void 0;
+  S(i2);
+}
+function x(i2) {
+  if (r !== this) throw new Error("Out-of-order effect");
+  b(this);
+  r = i2;
+  this.f &= -2;
+  if (8 & this.f) m(this);
+  t();
+}
+function E(i2, t2) {
+  this.x = i2;
+  this.m = void 0;
+  this.s = void 0;
+  this.u = void 0;
+  this.f = 32;
+  this.name = null == t2 ? void 0 : t2.name;
+}
+E.prototype.c = function() {
+  var i2 = this.S();
+  try {
+    if (8 & this.f) return;
+    if (void 0 === this.x) return;
+    var t2 = this.x();
+    if ("function" == typeof t2) this.m = t2;
+  } finally {
+    i2();
+  }
+};
+E.prototype.S = function() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  this.f |= 1;
+  this.f &= -9;
+  S(this);
+  _(this);
+  s++;
+  var i2 = r;
+  r = this;
+  return x.bind(this, i2);
+};
+E.prototype.N = function() {
+  if (!(2 & this.f)) {
+    this.f |= 2;
+    this.u = h;
+    h = this;
+  }
+};
+E.prototype.d = function() {
+  this.f |= 8;
+  if (!(1 & this.f)) m(this);
+};
+E.prototype.dispose = function() {
+  this.d();
+};
+function j(i2, t2) {
+  var n2 = new E(i2, t2);
+  try {
+    n2.c();
+  } catch (i3) {
+    n2.d();
+    throw i3;
+  }
+  var r2 = n2.d.bind(n2);
+  r2[Symbol.dispose] = r2;
+  return r2;
+}
+function createSignal(value, options) {
+  return y(value, options);
+}
+function isSymbol(value) {
+  return typeof value === "symbol" || value instanceof Symbol;
+}
+const globalThis_ = typeof globalThis === "object" && globalThis || typeof window === "object" && window || typeof self === "object" && self || typeof global === "object" && global || /* @__PURE__ */ function() {
+  return this;
+}();
+function debounce(func, debounceMs, { signal, edges } = {}) {
+  let pendingThis = void 0;
+  let pendingArgs = null;
+  const leading = edges != null && edges.includes("leading");
+  const trailing = edges == null || edges.includes("trailing");
+  const invoke = () => {
+    if (pendingArgs !== null) {
+      func.apply(pendingThis, pendingArgs);
+      pendingThis = void 0;
+      pendingArgs = null;
+    }
+  };
+  const onTimerEnd = () => {
+    if (trailing) invoke();
+    cancel();
+  };
+  let timeoutId = null;
+  const schedule = () => {
+    if (timeoutId != null) clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      onTimerEnd();
+    }, debounceMs);
+  };
+  const cancelTimer = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  const cancel = () => {
+    cancelTimer();
+    pendingThis = void 0;
+    pendingArgs = null;
+  };
+  const flush = () => {
+    invoke();
+  };
+  const debounced = function(...args) {
+    if (signal == null ? void 0 : signal.aborted) return;
+    pendingThis = this;
+    pendingArgs = args;
+    const isFirstCall = timeoutId == null;
+    schedule();
+    if (leading && isFirstCall) invoke();
+  };
+  debounced.schedule = schedule;
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  signal == null ? void 0 : signal.addEventListener("abort", cancel, { once: true });
+  return debounced;
+}
+function noop$1() {
+}
+function isPrimitive(value) {
+  return value == null || typeof value !== "object" && typeof value !== "function";
+}
+function isTypedArray(x2) {
+  return ArrayBuffer.isView(x2) && !(x2 instanceof DataView);
+}
+function isBuffer(x2) {
+  return typeof globalThis_.Buffer !== "undefined" && globalThis_.Buffer.isBuffer(x2);
+}
+function getSymbols(object) {
+  return Object.getOwnPropertySymbols(object).filter((symbol) => Object.prototype.propertyIsEnumerable.call(object, symbol));
+}
+function getTag(value) {
+  if (value == null) return value === void 0 ? "[object Undefined]" : "[object Null]";
+  return Object.prototype.toString.call(value);
+}
+const regexpTag = "[object RegExp]";
+const stringTag = "[object String]";
+const numberTag = "[object Number]";
+const booleanTag = "[object Boolean]";
+const argumentsTag = "[object Arguments]";
+const symbolTag = "[object Symbol]";
+const dateTag = "[object Date]";
+const mapTag = "[object Map]";
+const setTag = "[object Set]";
+const arrayTag = "[object Array]";
+const functionTag = "[object Function]";
+const arrayBufferTag = "[object ArrayBuffer]";
+const objectTag = "[object Object]";
+const errorTag = "[object Error]";
+const dataViewTag = "[object DataView]";
+const uint8ArrayTag = "[object Uint8Array]";
+const uint8ClampedArrayTag = "[object Uint8ClampedArray]";
+const uint16ArrayTag = "[object Uint16Array]";
+const uint32ArrayTag = "[object Uint32Array]";
+const bigUint64ArrayTag = "[object BigUint64Array]";
+const int8ArrayTag = "[object Int8Array]";
+const int16ArrayTag = "[object Int16Array]";
+const int32ArrayTag = "[object Int32Array]";
+const bigInt64ArrayTag = "[object BigInt64Array]";
+const float32ArrayTag = "[object Float32Array]";
+const float64ArrayTag = "[object Float64Array]";
+function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = /* @__PURE__ */ new Map(), cloneValue = void 0) {
+  const cloned = cloneValue == null ? void 0 : cloneValue(valueToClone, keyToClone, objectToClone, stack);
+  if (cloned !== void 0) return cloned;
+  if (isPrimitive(valueToClone)) return valueToClone;
+  if (stack.has(valueToClone)) return stack.get(valueToClone);
+  if (Array.isArray(valueToClone)) {
+    const result = new Array(valueToClone.length);
+    stack.set(valueToClone, result);
+    for (let i2 = 0; i2 < valueToClone.length; i2++) result[i2] = cloneDeepWithImpl(valueToClone[i2], i2, objectToClone, stack, cloneValue);
+    if (Object.hasOwn(valueToClone, "index")) result.index = valueToClone.index;
+    if (Object.hasOwn(valueToClone, "input")) result.input = valueToClone.input;
+    return result;
+  }
+  if (valueToClone instanceof Date) return new Date(valueToClone.getTime());
+  if (valueToClone instanceof RegExp) {
+    const result = new RegExp(valueToClone.source, valueToClone.flags);
+    result.lastIndex = valueToClone.lastIndex;
+    return result;
+  }
+  if (valueToClone instanceof Map) {
+    const result = /* @__PURE__ */ new Map();
+    stack.set(valueToClone, result);
+    for (const [key, value] of valueToClone) result.set(key, cloneDeepWithImpl(value, key, objectToClone, stack, cloneValue));
+    return result;
+  }
+  if (valueToClone instanceof Set) {
+    const result = /* @__PURE__ */ new Set();
+    stack.set(valueToClone, result);
+    for (const value of valueToClone) result.add(cloneDeepWithImpl(value, void 0, objectToClone, stack, cloneValue));
+    return result;
+  }
+  if (isBuffer(valueToClone)) return valueToClone.subarray();
+  if (isTypedArray(valueToClone)) {
+    const result = new (Object.getPrototypeOf(valueToClone)).constructor(valueToClone.length);
+    stack.set(valueToClone, result);
+    for (let i2 = 0; i2 < valueToClone.length; i2++) result[i2] = cloneDeepWithImpl(valueToClone[i2], i2, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && valueToClone instanceof SharedArrayBuffer) return valueToClone.slice(0);
+  if (valueToClone instanceof DataView) {
+    const result = new DataView(valueToClone.buffer.slice(0), valueToClone.byteOffset, valueToClone.byteLength);
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (typeof File !== "undefined" && valueToClone instanceof File) {
+    const result = new File([valueToClone], valueToClone.name, { type: valueToClone.type });
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (typeof Blob !== "undefined" && valueToClone instanceof Blob) {
+    const result = new Blob([valueToClone], { type: valueToClone.type });
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof Error) {
+    const result = structuredClone(valueToClone);
+    stack.set(valueToClone, result);
+    result.message = valueToClone.message;
+    result.name = valueToClone.name;
+    result.stack = valueToClone.stack;
+    result.cause = valueToClone.cause;
+    result.constructor = valueToClone.constructor;
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof Boolean) {
+    const result = new Boolean(valueToClone.valueOf());
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof Number) {
+    const result = new Number(valueToClone.valueOf());
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof String) {
+    const result = new String(valueToClone.valueOf());
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (typeof valueToClone === "object" && isCloneableObject(valueToClone)) {
+    const result = Object.create(Object.getPrototypeOf(valueToClone));
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  return valueToClone;
+}
+function copyProperties(target, source, objectToClone = target, stack, cloneValue) {
+  const keys = [...Object.keys(source), ...getSymbols(source)];
+  for (let i2 = 0; i2 < keys.length; i2++) {
+    const key = keys[i2];
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    if (descriptor == null || descriptor.writable) target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue);
+  }
+}
+function isCloneableObject(object) {
+  switch (getTag(object)) {
+    case argumentsTag:
+    case arrayTag:
+    case arrayBufferTag:
+    case dataViewTag:
+    case booleanTag:
+    case dateTag:
+    case float32ArrayTag:
+    case float64ArrayTag:
+    case int8ArrayTag:
+    case int16ArrayTag:
+    case int32ArrayTag:
+    case mapTag:
+    case numberTag:
+    case objectTag:
+    case regexpTag:
+    case setTag:
+    case stringTag:
+    case symbolTag:
+    case uint8ArrayTag:
+    case uint8ClampedArrayTag:
+    case uint16ArrayTag:
+    case uint32ArrayTag:
+      return true;
+    default:
+      return false;
+  }
+}
+function cloneDeep(obj) {
+  return cloneDeepWithImpl(obj, void 0, obj, /* @__PURE__ */ new Map(), void 0);
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  if (!(proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null)) return false;
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+function isUnsafeProperty(key) {
+  return key === "__proto__";
+}
+function pick(obj, keys) {
+  const result = {};
+  for (let i2 = 0; i2 < keys.length; i2++) {
+    const key = keys[i2];
+    if (Object.hasOwn(obj, key)) result[key] = obj[key];
+  }
+  return result;
+}
+function isEqualsSameValueZero(value, other) {
+  return value === other || Number.isNaN(value) && Number.isNaN(other);
+}
+function isEqualWith(a2, b2, areValuesEqual) {
+  return isEqualWithImpl(a2, b2, void 0, void 0, void 0, void 0, areValuesEqual);
+}
+function isEqualWithImpl(a2, b2, property, aParent, bParent, stack, areValuesEqual) {
+  const result = areValuesEqual(a2, b2, property, aParent, bParent, stack);
+  if (result !== void 0) return result;
+  if (typeof a2 === typeof b2) switch (typeof a2) {
+    case "bigint":
+    case "string":
+    case "boolean":
+    case "symbol":
+    case "undefined":
+      return a2 === b2;
+    case "number":
+      return a2 === b2 || Object.is(a2, b2);
+    case "function":
+      return a2 === b2;
+    case "object":
+      return areObjectsEqual(a2, b2, stack, areValuesEqual);
+  }
+  return areObjectsEqual(a2, b2, stack, areValuesEqual);
+}
+function areObjectsEqual(a2, b2, stack, areValuesEqual) {
+  if (Object.is(a2, b2)) return true;
+  let aTag = getTag(a2);
+  let bTag = getTag(b2);
+  if (aTag === "[object Arguments]") aTag = objectTag;
+  if (bTag === "[object Arguments]") bTag = objectTag;
+  if (aTag !== bTag) return false;
+  switch (aTag) {
+    case stringTag:
+      return a2.toString() === b2.toString();
+    case numberTag:
+      return isEqualsSameValueZero(a2.valueOf(), b2.valueOf());
+    case booleanTag:
+    case dateTag:
+    case symbolTag:
+      return Object.is(a2.valueOf(), b2.valueOf());
+    case regexpTag:
+      return a2.source === b2.source && a2.flags === b2.flags;
+    case functionTag:
+      return a2 === b2;
+  }
+  stack = stack ?? /* @__PURE__ */ new Map();
+  const aStack = stack.get(a2);
+  const bStack = stack.get(b2);
+  if (aStack != null && bStack != null) return aStack === b2;
+  stack.set(a2, b2);
+  stack.set(b2, a2);
+  try {
+    switch (aTag) {
+      case mapTag:
+        if (a2.size !== b2.size) return false;
+        for (const [key, value] of a2.entries()) if (!b2.has(key) || !isEqualWithImpl(value, b2.get(key), key, a2, b2, stack, areValuesEqual)) return false;
+        return true;
+      case setTag: {
+        if (a2.size !== b2.size) return false;
+        const aValues = Array.from(a2.values());
+        const bValues = Array.from(b2.values());
+        for (let i2 = 0; i2 < aValues.length; i2++) {
+          const aValue = aValues[i2];
+          const index = bValues.findIndex((bValue) => {
+            return isEqualWithImpl(aValue, bValue, void 0, a2, b2, stack, areValuesEqual);
+          });
+          if (index === -1) return false;
+          bValues.splice(index, 1);
+        }
+        return true;
+      }
+      case arrayTag:
+      case uint8ArrayTag:
+      case uint8ClampedArrayTag:
+      case uint16ArrayTag:
+      case uint32ArrayTag:
+      case bigUint64ArrayTag:
+      case int8ArrayTag:
+      case int16ArrayTag:
+      case int32ArrayTag:
+      case bigInt64ArrayTag:
+      case float32ArrayTag:
+      case float64ArrayTag:
+        if (isBuffer(a2) !== isBuffer(b2)) return false;
+        if (a2.length !== b2.length) return false;
+        for (let i2 = 0; i2 < a2.length; i2++) if (!isEqualWithImpl(a2[i2], b2[i2], i2, a2, b2, stack, areValuesEqual)) return false;
+        return true;
+      case arrayBufferTag:
+        if (a2.byteLength !== b2.byteLength) return false;
+        return areObjectsEqual(new Uint8Array(a2), new Uint8Array(b2), stack, areValuesEqual);
+      case dataViewTag:
+        if (a2.byteLength !== b2.byteLength || a2.byteOffset !== b2.byteOffset) return false;
+        return areObjectsEqual(new Uint8Array(a2), new Uint8Array(b2), stack, areValuesEqual);
+      case errorTag:
+        return a2.name === b2.name && a2.message === b2.message;
+      case objectTag: {
+        if (!(areObjectsEqual(a2.constructor, b2.constructor, stack, areValuesEqual) || isPlainObject(a2) && isPlainObject(b2))) return false;
+        const aKeys = [...Object.keys(a2), ...getSymbols(a2)];
+        const bKeys = [...Object.keys(b2), ...getSymbols(b2)];
+        if (aKeys.length !== bKeys.length) return false;
+        for (let i2 = 0; i2 < aKeys.length; i2++) {
+          const propKey = aKeys[i2];
+          const aProp = a2[propKey];
+          if (!Object.hasOwn(b2, propKey)) return false;
+          const bProp = b2[propKey];
+          if (!isEqualWithImpl(aProp, bProp, propKey, a2, b2, stack, areValuesEqual)) return false;
+        }
+        return true;
+      }
+      default:
+        return false;
+    }
+  } finally {
+    stack.delete(a2);
+    stack.delete(b2);
+  }
+}
+function isEqual(a2, b2) {
+  return isEqualWith(a2, b2, noop$1);
+}
+function createFieldSignal(options) {
+  const { value, initialValue, touched, pending } = options || {};
+  const valueSignal = createSignal(
+    value === void 0 ? void 0 : cloneDeep(value)
+  );
+  const initialSignal = createSignal(
+    initialValue === void 0 ? void 0 : cloneDeep(initialValue)
+  );
+  const touchedSignal = createSignal(touched ?? false);
+  const pendingSignal = createSignal(pending ?? false);
+  const pendingMessageSignal = createSignal([]);
+  const setValue = (next) => {
+    valueSignal.value = next;
+  };
+  const setInitialValue = (next) => {
+    initialSignal.value = next;
+  };
+  const setTouched = (next) => {
+    touchedSignal.value = next;
+  };
+  const setPending = (next, message) => {
+    pendingSignal.value = next;
+    if (next) {
+      if (message) {
+        pendingMessageSignal.value = Array.isArray(message) ? message : [message];
+      }
+    } else {
+      pendingMessageSignal.value = [];
+    }
+  };
+  const reset = (next = initialSignal.peek()) => {
+    valueSignal.value = cloneDeep(next);
+    touchedSignal.value = false;
+    pendingSignal.value = false;
+  };
+  const peek = () => {
+    return {
+      value: valueSignal.peek(),
+      initialValue: initialSignal.peek(),
+      touched: touchedSignal.peek(),
+      pending: pendingSignal.peek(),
+      pendingMessage: pendingMessageSignal.peek()
+    };
+  };
+  return {
+    value: valueSignal,
+    initialValue: initialSignal,
+    touched: touchedSignal,
+    pending: pendingSignal,
+    pendingMessage: pendingMessageSignal,
+    setValue,
+    setInitialValue,
+    setTouched,
+    setPending,
+    reset,
+    peek
+  };
+}
+class FieldSignalMapImpl {
+  constructor(options = {}) {
+    __publicField(this, "records", /* @__PURE__ */ new Map());
+    __publicField(this, "version", createSignal(0));
+    __publicField(this, "normalizeKey");
+    this.normalizeKey = options.normalizeKey ?? defaultNormalizeFieldKey;
+  }
+  /**
+   * 获取字段 key 的标准化字符串。
+   */
+  getKey(key) {
+    return this.normalizeKey(key);
+  }
+  /**
+   * 获取字段 signal。
+   *
+   * 读取缺失 key 时会订阅结构版本；后续 set 同 key 会触发 effect 重跑。
+   *
+   * @param key - 字段路径。
+   * @returns 字段 signal；未创建时返回 undefined。
+   */
+  get(key) {
+    const record = this.records.get(this.getKey(key));
+    if (record) {
+      return record.value;
+    }
+    void this.version.value;
+    return void 0;
+  }
+  /**
+   * 无依赖追踪地获取字段 signal。
+   *
+   * @param key - 字段路径。
+   * @returns 字段 signal；未创建时返回 undefined。
+   */
+  peek(key) {
+    var _a;
+    return (_a = this.records.get(this.getKey(key))) == null ? void 0 : _a.value;
+  }
+  /**
+   * 设置字段 signal。
+   *
+   * @param key - 字段路径。
+   * @param value - 字段 signal。
+   * @returns 当前映射实例，便于链式调用。
+   */
+  set(key, value) {
+    const normalizedKey = this.getKey(key);
+    const exists = this.records.has(normalizedKey);
+    this.records.set(normalizedKey, { key, value });
+    if (!exists) {
+      this.version.value++;
+    }
+    return this;
+  }
+  /**
+   * 判断字段是否存在。
+   *
+   * @param key - 字段路径。
+   * @returns 字段 signal 是否已存在。
+   */
+  has(key) {
+    return this.records.has(this.getKey(key));
+  }
+  /**
+   * 删除字段 signal。
+   *
+   * @param key - 字段路径。
+   * @returns 是否删除了已存在的字段 signal。
+   */
+  delete(key) {
+    const normalizedKey = this.getKey(key);
+    const record = this.records.get(normalizedKey);
+    if (!record) return false;
+    this.records.delete(normalizedKey);
+    disposeSignal(record.value);
+    this.version.value++;
+    return true;
+  }
+  /**
+   * 清空所有字段 signal。
+   */
+  clear() {
+    if (this.records.size === 0) return;
+    for (const record of this.records.values()) {
+      disposeSignal(record.value);
+    }
+    this.records.clear();
+    this.version.value++;
+  }
+  /**
+   * 响应式遍历原始字段 key。
+   *
+   * @returns 原始字段 key 的迭代器。
+   */
+  keys() {
+    void this.version.value;
+    return Array.from(this.records.values(), (record) => record.key).values();
+  }
+  /**
+   * 响应式遍历字段 signal。
+   *
+   * @returns 字段 signal 的迭代器。
+   */
+  values() {
+    void this.version.value;
+    return Array.from(this.records.values(), (record) => record.value).values();
+  }
+  /**
+   * 响应式遍历 `[key, signal]`。
+   *
+   * @returns 原始字段 key 与字段 signal 的迭代器。
+   */
+  entries() {
+    void this.version.value;
+    return Array.from(
+      this.records.values(),
+      (record) => [record.key, record.value]
+    ).values();
+  }
+}
+function createFieldSignalMap(options = {}) {
+  return new FieldSignalMapImpl(options);
+}
+function disposeSignal(signal) {
+  signal.value.value = void 0;
+  signal.initialValue.value = void 0;
+  signal.touched.value = false;
+  signal.pending.value = false;
+}
+function defaultNormalizeFieldKey(key) {
+  if (Array.isArray(key)) {
+    return key.map((part) => String(part)).join(".");
+  }
+  return String(key);
+}
+function createSignalEffect(fn) {
+  return j(fn);
+}
+function createDebouncedSignalEffect(collect, run, wait = 16, options = {}) {
+  const debouncedRun = debounce(run, wait, { edges: options.edges });
+  let initialized = false;
+  const disposeEffect = createSignalEffect(() => {
+    const value = collect();
+    if (!initialized && options.immediate) {
+      initialized = true;
+      run(value);
+      return;
+    }
+    initialized = true;
+    debouncedRun(value);
+  });
+  return () => {
+    disposeEffect();
+    debouncedRun.cancel();
+  };
+}
+function batchUpdates(fn) {
+  n(fn);
+}
+class SignalMapImpl {
+  constructor() {
+    __publicField(this, "signals", /* @__PURE__ */ new Map());
+    __publicField(this, "version", createSignal(0));
+  }
+  /**
+   * 读取 key，并在 effect 内自动收集响应式依赖。
+   *
+   * @param key - 待读取的 key。
+   * @returns key 对应的值；不存在时返回 undefined。
+   */
+  get(key) {
+    const s2 = this.signals.get(key);
+    if (s2) return s2.value;
+    void this.version.value;
+    return void 0;
+  }
+  /**
+   * 写入 key；如果 key 不存在，则创建新的 signal。
+   *
+   * @param key - 待写入的 key。
+   * @param value - 新值。
+   * @returns 当前 SignalMap 实例，便于链式调用。
+   */
+  set(key, value) {
+    const s2 = this.signals.get(key);
+    if (s2) {
+      s2.value = value;
+    } else {
+      this.signals.set(key, createSignal(value));
+      this.version.value++;
+    }
+    return this;
+  }
+  /**
+   * 无依赖追踪地读取 key。
+   *
+   * @param key - 待读取的 key。
+   * @returns key 对应的值；不存在时返回 undefined。
+   */
+  peek(key) {
+    var _a;
+    return (_a = this.signals.get(key)) == null ? void 0 : _a.peek();
+  }
+  /**
+   * 判断 key 是否存在。
+   *
+   * @param key - 待检查的 key。
+   * @returns key 已存在时返回 true。
+   */
+  has(key) {
+    return this.signals.has(key);
+  }
+  /**
+   * 删除 key，并通知订阅旧 signal 或 map 结构的 effects。
+   *
+   * @param key - 待删除的 key。
+   * @returns 成功删除时返回 true；key 不存在时返回 false。
+   */
+  delete(key) {
+    const s2 = this.signals.get(key);
+    if (!s2) return false;
+    this.signals.delete(key);
+    batchUpdates(() => {
+      s2.value = void 0;
+      this.version.value++;
+    });
+    return true;
+  }
+  /**
+   * 清空所有 key，并通知订阅任意被删除 signal 的 effects。
+   */
+  clear() {
+    if (this.signals.size === 0) return;
+    const oldSignals = [...this.signals.values()];
+    this.signals.clear();
+    batchUpdates(() => {
+      for (const s2 of oldSignals) {
+        s2.value = void 0;
+      }
+      this.version.value++;
+    });
+  }
+  /**
+   * 遍历所有已注册 key。
+   *
+   * @returns key 迭代器。
+   */
+  keys() {
+    void this.version.value;
+    return this.signals.keys();
+  }
+  /**
+   * 遍历所有值。
+   *
+   * @returns value 迭代器。
+   */
+  values() {
+    void this.version.value;
+    return Array.from(this.signals.values(), (signal) => signal.value).values();
+  }
+  /**
+   * 遍历 key/value 对。
+   *
+   * @returns key/value entry 迭代器。
+   */
+  entries() {
+    void this.version.value;
+    return Array.from(
+      this.signals.entries(),
+      ([key, signal]) => [key, signal.value]
+    ).values();
+  }
+}
+function createSignalMap() {
+  return new SignalMapImpl();
+}
+function isBaseSchema(schema) {
+  return !isGroupSchema(schema) && !isDependencySchema(schema);
+}
+function isGroupSchema(schema) {
+  return schema.componentType === "group";
+}
+function isDependencySchema(schema) {
+  return schema.componentType === "dependency";
+}
+function isBaseResolvedSchema(schema) {
+  return !isGroupResolvedSchema(schema) && !isDependencyResolvedSchema(schema);
+}
+function isGroupResolvedSchema(schema) {
+  return schema.componentType === "group";
+}
+function isDependencyResolvedSchema(schema) {
+  return schema.componentType === "dependency";
+}
+const isLegalName = (schema) => Object.hasOwn(schema, "name") && [null, void 0, ""].every((i2) => i2 !== schema.name);
+const isLegalComponentType = (schema) => Object.hasOwn(schema, "componentType") && typeof schema.componentType === "string";
+function getBaseFieldMissing(schema) {
+  const missing = [];
+  if (!isLegalName(schema)) missing.push("name");
+  if (!isLegalComponentType(schema)) missing.push("componentType");
+  return missing;
+}
+function getGroupFieldMissing(schema) {
+  const missing = [];
+  if (!isLegalComponentType(schema)) missing.push("componentType");
+  if (!Object.hasOwn(schema, "children") || !Array.isArray(schema.children))
+    missing.push("children");
+  return missing;
+}
+function getDependencyFieldMissing(schema) {
+  const missing = [];
+  if (!isLegalComponentType(schema)) missing.push("componentType");
+  if (!Object.hasOwn(schema, "to") || !Array.isArray(schema.to)) missing.push("to");
+  if (typeof schema.renderer !== "function") missing.push("renderer");
+  return missing;
+}
+function buildWarnMessage(index, schema, missing) {
+  const identifier = "name" in schema && schema.name || schema.componentType || "unknown";
+  return `[schemx] schemas[${index}] (${String(identifier)}) 缺少必填项: ${missing.join(", ")}，已被过滤`;
+}
+function normalizeSchemas(schemas) {
+  const result = [];
+  const missings = [];
+  for (let i2 = 0; i2 < schemas.length; i2++) {
+    const schema = schemas[i2];
+    let missing = [];
+    if (isGroupSchema(schema)) {
+      missing = getGroupFieldMissing(schema);
+      if (missing.length > 0) {
+        missings.push(buildWarnMessage(i2, schema, missing));
+        continue;
+      }
+      result.push({
+        ...schema,
+        children: normalizeSchemas(schema.children)
+      });
+    } else if (isDependencySchema(schema)) {
+      missing = getDependencyFieldMissing(schema);
+      if (missing.length > 0) {
+        missings.push(buildWarnMessage(i2, schema, missing));
+        continue;
+      }
+      result.push(schema);
+    } else if (isBaseSchema(schema)) {
+      missing = getBaseFieldMissing(schema);
+      if (missing.length > 0) {
+        missings.push(buildWarnMessage(i2, schema, missing));
+        continue;
+      }
+      result.push(schema);
+    }
+  }
+  if (missings.length) console.warn(missings.join("\n"));
+  return result;
+}
+function toString(value) {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return value.map(toString).join(",");
+  const result = String(value);
+  if (result === "0" && Object.is(Number(value), -0)) return "-0";
+  return result;
+}
+function toKey(value) {
+  var _a;
+  if (typeof value === "string" || typeof value === "symbol") return value;
+  if (Object.is((_a = value == null ? void 0 : value.valueOf) == null ? void 0 : _a.call(value), -0)) return "-0";
+  return String(value);
+}
+function toPath(deepKey) {
+  if (Array.isArray(deepKey)) return deepKey.map(toKey);
+  if (typeof deepKey === "symbol") return [deepKey];
+  deepKey = toString(deepKey);
+  const result = [];
+  const length = deepKey.length;
+  if (length === 0) return result;
+  let index = 0;
+  let key = "";
+  let quoteChar = "";
+  let bracket = false;
+  if (deepKey.charCodeAt(0) === 46) {
+    result.push("");
+    index++;
+  }
+  while (index < length) {
+    const char = deepKey[index];
+    if (quoteChar) if (char === "\\" && index + 1 < length) {
+      index++;
+      key += deepKey[index];
+    } else if (char === quoteChar) quoteChar = "";
+    else key += char;
+    else if (bracket) if (char === '"' || char === "'") quoteChar = char;
+    else if (char === "]") {
+      bracket = false;
+      result.push(key);
+      key = "";
+    } else key += char;
+    else if (char === "[") {
+      bracket = true;
+      if (key) {
+        result.push(key);
+        key = "";
+      }
+    } else if (char === ".") {
+      if (key) {
+        result.push(key);
+        key = "";
+      }
+    } else key += char;
+    index++;
+  }
+  if (key) result.push(key);
+  return result;
+}
+function isDeepKey(key) {
+  switch (typeof key) {
+    case "number":
+    case "symbol":
+      return false;
+    case "string":
+      return key.includes(".") || key.includes("[") || key.includes("]");
+  }
+}
+function get(object, path, defaultValue) {
+  if (object == null) return defaultValue;
+  switch (typeof path) {
+    case "string": {
+      if (isUnsafeProperty(path)) return defaultValue;
+      const result = object[path];
+      if (result === void 0) if (isDeepKey(path)) return get(object, toPath(path), defaultValue);
+      else return defaultValue;
+      return result;
+    }
+    case "number":
+    case "symbol": {
+      if (typeof path === "number") path = toKey(path);
+      const result = object[path];
+      if (result === void 0) return defaultValue;
+      return result;
+    }
+    default: {
+      if (Array.isArray(path)) return getWithPath(object, path, defaultValue);
+      if (Object.is(path == null ? void 0 : path.valueOf(), -0)) path = "-0";
+      else path = String(path);
+      if (isUnsafeProperty(path)) return defaultValue;
+      const result = object[path];
+      if (result === void 0) return defaultValue;
+      return result;
+    }
+  }
+}
+function getWithPath(object, path, defaultValue) {
+  if (path.length === 0) return defaultValue;
+  let current = object;
+  for (let index = 0; index < path.length; index++) {
+    if (current == null) return defaultValue;
+    if (isUnsafeProperty(path[index])) return defaultValue;
+    current = current[path[index]];
+  }
+  if (current === void 0) return defaultValue;
+  return current;
+}
+function isObject(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function");
+}
+const IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length = Number.MAX_SAFE_INTEGER) {
+  switch (typeof value) {
+    case "number":
+      return Number.isInteger(value) && value >= 0 && value < length;
+    case "symbol":
+      return false;
+    case "string":
+      return IS_UNSIGNED_INTEGER.test(value);
+  }
+}
+const regexIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+const regexIsPlainProp = /^\w*$/;
+function isKey(value, object) {
+  if (Array.isArray(value)) return false;
+  if (typeof value === "number" || typeof value === "boolean" || value == null || isSymbol(value)) return true;
+  return typeof value === "string" && (regexIsPlainProp.test(value) || !regexIsDeepProp.test(value)) || object != null && Object.hasOwn(object, value);
+}
+const assignValue = (object, key, value) => {
+  const objValue = object[key];
+  if (!(Object.hasOwn(object, key) && isEqualsSameValueZero(objValue, value)) || value === void 0 && !(key in object)) object[key] = value;
+};
+function updateWith(obj, path, updater, customizer) {
+  if (obj == null && !isObject(obj)) return obj;
+  let resolvedPath;
+  if (isKey(path, obj)) resolvedPath = [path];
+  else if (Array.isArray(path)) resolvedPath = path;
+  else resolvedPath = toPath(path);
+  const updateValue = updater(get(obj, resolvedPath));
+  let current = obj;
+  for (let i2 = 0; i2 < resolvedPath.length && current != null; i2++) {
+    const key = toKey(resolvedPath[i2]);
+    if (isUnsafeProperty(key)) continue;
+    let newValue;
+    if (i2 === resolvedPath.length - 1) newValue = updateValue;
+    else {
+      const objValue = current[key];
+      const customizerResult = customizer == null ? void 0 : customizer(objValue, key, obj);
+      newValue = customizerResult !== void 0 ? customizerResult : isObject(objValue) ? objValue : isIndex(resolvedPath[i2 + 1]) ? [] : {};
+    }
+    assignValue(current, key, newValue);
+    current = current[key];
+  }
+  return obj;
+}
+function set(obj, path, value) {
+  return updateWith(obj, path, () => value, () => void 0);
+}
+function getByPath(obj, path) {
+  if (path === "" || Array.isArray(path) && path.length === 0) {
+    return obj;
+  }
+  return get(obj, normalizeRuntimePath(path));
+}
+function setByPath(obj, path, value) {
+  if (obj == null) return;
+  set(obj, normalizeRuntimePath(path), value);
+}
+function collectObjectPathsByLeaf(obj, prefix = "") {
+  const paths = [];
+  for (const key of Object.keys(obj)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    const value = obj[key];
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        const itemPath = `${path}[${index}]`;
+        if (item !== null && typeof item === "object") {
+          paths.push(...collectObjectPathsByLeaf(item, itemPath));
+        } else {
+          paths.push(itemPath);
+        }
+      });
+    } else if (value !== null && typeof value === "object") {
+      paths.push(...collectObjectPathsByLeaf(value, path));
+    } else {
+      paths.push(path);
+    }
+  }
+  return paths;
+}
+const normalizeRuntimePath = (path) => {
+  if (Array.isArray(path)) {
+    return path.map((part) => typeof part === "number" ? part : String(part));
+  }
+  return path;
+};
+function withLock(fn) {
+  let pending = null;
+  return (...args) => {
+    if (pending) return pending;
+    pending = fn(...args).finally(() => {
+      pending = null;
+    });
+    return pending;
+  };
+}
+function diff(current, prev) {
+  const changedValues = {};
+  for (const key of Object.keys(current)) {
+    if (!isEqual(current[key], prev[key])) {
+      changedValues[key] = current[key];
+    }
+  }
+  return changedValues;
+}
+const defaultConfig = {
+  /**
+   * 是否展示必填的 * 号（静态默认值）
+   *
+   * 控制必填标记（红色星号）的显示。
+   * 若未设置，会根据 `rules` 中的校验规则自动推断。
+   */
+  required: false,
+  /**
+   * 是否只读（静态默认值）
+   *
+   * 未设置时继承 FormContext 的全局 `readonly` 配置。
+   */
+  readonly: false,
+  /**
+   * 是否禁用（静态默认值）
+   *
+   * 未设置时继承 FormContext 的全局 `disabled` 配置。
+   */
+  disabled: false,
+  /**
+   * 是否可见（静态默认值）
+   *
+   * 不可见时字段不渲染，同时会清除校验规则和错误信息。
+   */
+  visible: true,
+  /**
+   * 标签图标
+   *
+   * 显示在 label 文本旁的图标标识。
+   */
+  labelIcon: "",
+  /**
+   * 标签对齐方式
+   *
+   * 未设置时继承 FormContext 的全局 `labelAlign` 配置。
+   */
+  labelAlign: "left",
+  /**
+   * 标签位置
+   *
+   * 未设置时继承 FormContext 的全局 `labelPosition` 配置。
+   */
+  labelPosition: "left",
+  /**
+   * 标签宽度
+   *
+   * 未设置时继承 FormContext 的全局 `labelWidth` 配置。
+   */
+  labelWidth: "auto",
+  /**
+   * 校验触发时机
+   *
+   * 支持单个或多个触发时机组合，如 `'change'`、`'blur'`、`['change', 'blur']`。
+   * 未设置时继承 FormContext 的全局 `validationTrigger` 配置。
+   */
+  validationTrigger: "blur",
+  /**
+   * 是否在标签后显示冒号
+   *
+   * 未设置时继承 FormContext 的全局 `colon` 配置。
+   */
+  colon: true
+};
+const defaultConfigKey = Object.keys(defaultConfig);
+class ValidatorImpl {
+  constructor() {
+    __publicField(this, "rules", /* @__PURE__ */ new Map());
+    __publicField(this, "errors", createSignalMap());
+  }
+  /**
+   * 注册单个字段的校验规则。
+   *
+   * 支持传入单个 schema 或 schema 数组，多次调用会追加规则而非覆盖。
+   *
+   * @param path - 字段路径
+   * @param rules - 单个或多个 StandardSchemaV1 校验 schema
+   * @param defaultMessage - 可选，空值（undefined/null）时的默认错误提示
+   *
+   * @example
+   * ```typescript
+   * validator.register('email', emailSchema)
+   * validator.register('name', [minLenSchema, maxLenSchema], '请输入姓名')
+   * ```
+   */
+  register(path, rules, defaultMessage) {
+    const schemas = Array.isArray(rules) ? rules : [rules];
+    const existing = this.rules.get(path);
+    if (existing) {
+      existing.schemas.push(...schemas);
+      if (defaultMessage) {
+        existing.defaultMessage = defaultMessage;
+      }
+    } else {
+      this.rules.set(path, { schemas, defaultMessage });
+    }
+  }
+  /**
+   * 注销单个字段的校验规则，同时清除该字段的错误信息。
+   *
+   * @param path - 字段路径
+   *
+   * @example
+   * ```typescript
+   * validator.unregister('email')
+   * ```
+   */
+  unregister(path) {
+    this.rules.delete(path);
+    this.errors.delete(path);
+  }
+  /**
+   * 获取指定字段的错误信息。
+   *
+   * @param path - 字段路径
+   * @returns 错误信息数组，无错误时返回 undefined
+   *
+   * @example
+   * ```typescript
+   * validator.getFieldError('email') // => ['邮箱格式不正确']
+   * ```
+   */
+  getFieldError(path) {
+    return this.errors.get(path);
+  }
+  /**
+   * 手动设置指定字段的错误信息。
+   *
+   * @param path - 字段路径
+   * @param errors - 错误信息数组
+   *
+   * @example
+   * ```typescript
+   * validator.setFieldError('email', ['该邮箱已被注册'])
+   * ```
+   */
+  setFieldError(path, errors) {
+    this.errors.set(path, errors);
+  }
+  /**
+   * 校验指定字段。
+   *
+   * 支持传入单个路径或路径数组，逐个校验后返回汇总结果。
+   *
+   * @param path - 字段路径或路径数组
+   * @param latestValues - 当前表单全量值
+   * @returns 校验结果
+   *
+   * @example
+   * ```typescript
+   * const result = await validator.validateField('email', formValues)
+   * const result = await validator.validateField(['name', 'email'], formValues)
+   *
+   * if (!result.ok) console.log(result.error.errors)
+   * ```
+   */
+  async validateField(path, latestValues) {
+    const paths = Array.isArray(path) ? path : [path];
+    this.reset(paths);
+    let allValid = true;
+    for (const p2 of paths) {
+      const result = await this.validateSingleRule(p2, latestValues);
+      if (!result.ok) allValid = false;
+    }
+    return this.buildResult(allValid, latestValues);
+  }
+  /**
+   * 校验所有已注册规则的字段。
+   *
+   * 校验前清空所有错误，逐个校验后返回汇总结果。
+   *
+   * @param latestValues - 当前表单全量值
+   * @returns 校验结果
+   *
+   * @example
+   * ```typescript
+   * const result = await validator.validate(formValues)
+   * if (result.ok) submit(result.values)
+   * ```
+   */
+  async validate(latestValues) {
+    let allValid = true;
+    this.reset();
+    for (const path of this.rules.keys()) {
+      const result = await this.validateSingleRule(path, latestValues);
+      if (!result.ok) allValid = false;
+    }
+    return this.buildResult(allValid, latestValues);
+  }
+  /**
+   * 重置所有字段的校验错误。
+   *
+   * 清空 errors 映射表，不影响已注册的校验规则。
+   *
+   * @param paths - 可选的字段路径数组；不传时重置所有已注册字段。
+   *
+   * @example
+   * ```typescript
+   * validator.resetErrors()
+   * ```
+   */
+  reset(paths) {
+    if (paths) {
+      batchUpdates(() => {
+        for (const key of paths) {
+          this.errors.set(key, []);
+        }
+      });
+      return;
+    }
+    batchUpdates(() => {
+      for (const key of this.rules.keys()) {
+        this.errors.set(key, []);
+      }
+      for (const key of [...this.errors.keys()]) {
+        if (!this.rules.has(key)) {
+          this.errors.delete(key);
+        }
+      }
+    });
+  }
+  /**
+   * 根据校验结果构建 ValidateResult 返回值。
+   *
+   * @param ok - 校验是否全部通过
+   * @param latestValues - 当前表单全量值
+   * @returns 统一的校验结果对象
+   */
+  buildResult(ok, latestValues) {
+    if (ok) {
+      return { ok: true, values: latestValues };
+    }
+    return {
+      ok: false,
+      error: {
+        errors: Array.from(this.errors.keys()).map((field) => ({
+          field,
+          message: this.errors.peek(field) || []
+        })),
+        values: latestValues
+      }
+    };
+  }
+  /**
+   * 记录字段错误并返回失败结果。
+   *
+   * @param path - 字段路径
+   * @param messages - 错误信息数组
+   * @param latestValues - 当前表单全量值
+   * @returns 失败的校验结果
+   */
+  failResult(path, messages, latestValues) {
+    this.errors.set(path, messages);
+    return {
+      ok: false,
+      error: {
+        errors: [{ field: path, message: messages }],
+        values: latestValues
+      }
+    };
+  }
+  /**
+   * 校验单个字段的所有规则。
+   *
+   * 依次执行该字段注册的所有 schema，遇到第一个失败即返回错误。
+   * 若值为 undefined/null 且配置了 defaultMessage，直接返回失败结果。
+   *
+   * @param path - 字段路径
+   * @param latestValues - 当前表单全量值
+   * @returns 校验结果
+   */
+  async validateSingleRule(path, latestValues) {
+    const entry = this.rules.get(path);
+    if (!entry || entry.schemas.length === 0) {
+      this.errors.delete(path);
+      return { ok: true, values: latestValues };
+    }
+    const value = getByPath(latestValues, path);
+    const allMessages = [];
+    if ((value === void 0 || value === null) && entry.defaultMessage) {
+      allMessages.push(entry.defaultMessage);
+    }
+    for (const schema of entry.schemas) {
+      try {
+        const result = await schema["~standard"].validate(value);
+        if (result.issues) {
+          allMessages.push(...result.issues.map((i2) => i2.message));
+        }
+      } catch (error) {
+        console.warn(`[Validator] 校验字段 "${path}" 时发生错误:`, error);
+        allMessages.push("校验失败");
+      }
+    }
+    if (allMessages.length > 0) {
+      return this.failResult(path, allMessages, latestValues);
+    }
+    this.errors.delete(path);
+    return { ok: true, values: latestValues };
+  }
+}
+function createValidator() {
+  return new ValidatorImpl();
+}
+function createRequiredRule(schema) {
+  const validate = (value) => {
+    if (value === void 0 || value === null || value === "") {
+      const label = (schema == null ? void 0 : schema.label) ?? "";
+      return standardIssueResult(label ? `请输入${label}` : "此项为必填项");
+    }
+    return standardValueResult(value);
+  };
+  return buildStandardSchema(validate);
+}
+function createSelectRequiredRule(schema) {
+  const validate = (value) => {
+    if (value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0) {
+      const label = (schema == null ? void 0 : schema.label) ?? "";
+      return standardIssueResult(label ? `请选择${label}` : "此项为必选项");
+    }
+    return standardValueResult(value);
+  };
+  return buildStandardSchema(validate);
+}
+function createUploadRequiredRule(schema) {
+  const validate = (value) => {
+    if (value === void 0 || value === null || Array.isArray(value) && value.length === 0) {
+      const label = (schema == null ? void 0 : schema.label) ?? "";
+      return standardIssueResult(label ? `请上传${label}` : "此项为必传项");
+    }
+    return standardValueResult(value);
+  };
+  return buildStandardSchema(validate);
+}
+const buildStandardSchema = (validate) => {
+  return {
+    "~standard": {
+      version: 1,
+      vendor: "schemx",
+      validate
+    }
+  };
+};
+const standardIssueResult = (message) => {
+  return {
+    issues: [{ message }]
+  };
+};
+const standardValueResult = (value) => {
+  return { value };
+};
+class RendererRegistry {
+  /**
+   * 创建 Registry 实例。
+   *
+   * @param defaultType - 默认渲染器类型，未找到指定类型时回退使用
+   */
+  constructor(defaultType) {
+    __publicField(this, "renderers");
+    __publicField(this, "defaultType");
+    this.renderers = /* @__PURE__ */ new Map();
+    this.defaultType = defaultType;
+  }
+  /**
+   * 注册渲染器。
+   *
+   * 默认会覆盖已存在的同名渲染器，可通过 `options.override` 控制。
+   *
+   * @param type - 渲染器类型标识
+   * @param renderer - 组件
+   * @param options - 注册选项
+   *
+   * @example
+   * ```typescript
+   * renderer.register('text', TextRenderer)
+   * renderer.register('text', NewTextRenderer, { override: true })
+   * ```
+   */
+  register(type, renderer, options) {
+    if (this.renderers.has(type) && (options == null ? void 0 : options.override) === false) {
+      console.warn(
+        `[RendererRegistryType] RendererRegistry "${type}" already exists, skipping registration`
+      );
+      return;
+    }
+    this.renderers.set(type, renderer);
+  }
+  /**
+   * 批量注册渲染器。
+   *
+   * 遍历映射对象逐个注册，已存在的同名渲染器会被直接覆盖。
+   *
+   * @param renderers - 类型到组件的映射对象
+   *
+   * @example
+   * ```typescript
+   * renderer.registerAll({
+   *   text: TextRenderer,
+   *   number: NumberRenderer,
+   *   date: DateRenderer,
+   * })
+   * ```
+   */
+  registerAll(renderers) {
+    Object.entries(renderers).forEach(([type, renderer]) => {
+      this.renderers.set(type, renderer);
+    });
+  }
+  /**
+   * 获取指定类型的渲染器组件。
+   *
+   * 未找到时自动回退到默认类型，默认类型也不存在则返回 undefined。
+   *
+   * @param type - 渲染器类型标识
+   * @returns 对应的组件，未找到且无默认时返回 undefined
+   *
+   * @example
+   * ```typescript
+   * const renderer = renderer.getRenderer('text')
+   * const fallback = renderer.getRenderer('unknown') // => 默认渲染器
+   * ```
+   */
+  getRenderer(type) {
+    let renderer = this.renderers.get(type);
+    if (!renderer) {
+      console.warn(
+        `[RendererRegistryType] RendererRegistry "${type}" not found, falling back to default "${this.defaultType}"`
+      );
+      if (this.defaultType) renderer = this.renderers.get(this.defaultType);
+    }
+    return renderer;
+  }
+  /**
+   * 检查渲染器是否已注册
+   *
+   * @param type - 渲染器类型标识
+   * @returns 是否存在
+   *
+   * @example
+   * ```typescript
+   * renderer.hasRenderer('text')   // => true
+   * renderer.hasRenderer('custom') // => false
+   * ```
+   */
+  hasRenderer(type) {
+    return this.renderers.has(type);
+  }
+  /**
+   * 移除渲染器
+   *
+   * 如果移除的是当前默认类型，会从剩余渲染器中智能选取新默认类型。
+   * 若无剩余渲染器则默认类型设为空字符串。
+   *
+   * @param type - 渲染器类型标识
+   * @returns 是否成功移除
+   *
+   * @example
+   * ```typescript
+   * renderer.unregister('date') // => true
+   * renderer.unregister('nonexistent') // => false
+   * ```
+   */
+  unregister(type) {
+    const isDefault = type === this.defaultType;
+    const deleted = this.renderers.delete(type);
+    if (isDefault && deleted) {
+      const firstKey = this.renderers.keys().next().value;
+      if (firstKey) {
+        console.warn(
+          `[RendererRegistryType] Default renderer was removed, Please reset the default renderer.`
+        );
+        this.defaultType = firstKey;
+      }
+    }
+    return deleted;
+  }
+  /**
+   * 获取所有已注册的渲染器类型
+   *
+   * @returns 类型标识数组
+   *
+   * @example
+   * ```typescript
+   * renderer.getTypes() // => ['text', 'number', 'date']
+   * ```
+   */
+  getTypes() {
+    return Array.from(this.renderers.keys());
+  }
+  /**
+   * 设置默认渲染器类型
+   *
+   * 当 getRenderer 找不到指定类型时，会回退到默认类型。
+   * 设置的类型必须已注册，否则操作无效。
+   *
+   * @param type - 渲染器类型标识
+   *
+   * @example
+   * ```typescript
+   * renderer.setDefault('number')
+   * renderer.getDefault() // => 'number'
+   * ```
+   */
+  setDefault(type) {
+    if (!this.renderers.has(type)) {
+      console.warn(
+        `[RendererRegistryType] Cannot set default to "${type}": renderer not registered`
+      );
+      return;
+    }
+    this.defaultType = type;
+  }
+  /**
+   * 获取当前默认渲染器类型
+   *
+   * @returns 默认类型标识
+   *
+   * @example
+   * ```typescript
+   * renderer.getDefault() // => 'text'
+   * ```
+   */
+  getDefault() {
+    return this.defaultType;
+  }
+  /**
+   * 清除所有已注册的渲染器并重置默认类型为 'text'。
+   *
+   * @example
+   * ```typescript
+   * renderer.clear()
+   * renderer.size() // => 0
+   * ```
+   */
+  clear() {
+    this.renderers.clear();
+  }
+  /**
+   * 获取已注册渲染器数量
+   *
+   * @returns 渲染器数量
+   *
+   * @example
+   * ```typescript
+   * renderer.size() // => 5
+   * ```
+   */
+  size() {
+    return this.renderers.size;
+  }
+}
+function createRendererRegistry(defaultType) {
+  return new RendererRegistry(defaultType);
+}
+class ValidatorsRegistry {
+  /**
+   * 创建 ValidatorsRegistryType 实例。
+   *
+   * 创建空的规则注册中心。
+   */
+  constructor() {
+    __publicField(this, "validators");
+    this.validators = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 注册校验规则。
+   *
+   * 支持 StandardSchemaV1 实例或工厂函数。
+   * 默认覆盖已存在的同名规则，可通过 `options.override` 控制。
+   *
+   * @param name - validators 名称
+   * @param validators - StandardSchemaV1 实例或工厂函数
+   * @param options - 注册选项
+   *
+   * @example
+   * ```typescript
+   * // 注册固定 validators
+   * validatorRegistry.register('phone', phoneValidators)
+   *
+   * // 注册工厂函数
+   * validatorRegistry.register('required', (schema) => createRequiredValidators(schema))
+   * ```
+   */
+  register(name, validators, options) {
+    if (this.validators.has(name) && (options == null ? void 0 : options.override) === false) {
+      console.warn(`[ValidatorsRegistryType] Validators "${name}" 已存在，跳过注册`);
+      return;
+    }
+    this.validators.set(name, validators);
+  }
+  /**
+   * 批量注册校验规则。
+   *
+   * 遍历映射对象逐个注册，已存在的同名规则会被直接覆盖。
+   *
+   * @param validators - 名称到 validators/工厂的映射对象
+   *
+   * @example
+   * ```typescript
+   * validatorRegistry.registerAll({
+   *   phone: phoneValidators,
+   *   required: (schema) => createRequiredValidators(schema),
+   * })
+   * ```
+   */
+  registerAll(validators) {
+    Object.entries(validators).forEach(([name, validators2]) => {
+      this.validators.set(name, validators2);
+    });
+  }
+  /**
+   * 获取指定名称的原始注册条目。
+   *
+   * 返回 StandardSchemaV1 实例或工厂函数，不做解析。
+   * 如需按字段 schema 自动解析字符串规则和工厂，请使用 {@link resolveValidatorsBySchema}。
+   *
+   * @param name - validators 名称
+   * @returns 对应的注册条目，未找到时返回 undefined
+   *
+   * @example
+   * ```typescript
+   * const entry = validatorRegistry.get('phone')
+   * ```
+   */
+  get(name) {
+    return this.validators.get(name);
+  }
+  /**
+   * 解析字段 schema 上声明的校验规则。
+   *
+   * 字符串规则会从注册表查找；若注册项是工厂函数，则传入完整字段 schema
+   * 生成 StandardSchemaV1 实例。已经是 StandardSchemaV1 的规则会原样返回。
+   *
+   * @param schema - 含 validators 的字段 schema。
+   * @returns 解析后的 StandardSchemaV1 实例数组。
+   *
+   * @example
+   * ```typescript
+   * // 固定 validators 直接返回
+   * validatorRegistry.resolveValidatorsBySchema({
+   *   name: 'phone',
+   *   label: '手机号',
+   *   componentType: 'input',
+   *   validators: 'phone',
+   * })
+   *
+   * // 工厂函数会被调用
+   * validatorRegistry.resolveValidatorsBySchema({
+   *   name: 'username',
+   *   label: '用户名',
+   *   componentType: 'input',
+   *   validators: 'required',
+   * })
+   * ```
+   */
+  resolveValidatorsBySchema(schema) {
+    const validators = (schema == null ? void 0 : schema.rules) ?? [];
+    const validatorsList = Array.isArray(validators) ? validators : [validators];
+    const resolved = [];
+    for (const validators2 of validatorsList) {
+      if (typeof validators2 === "string") {
+        if (this.validators.has(validators2)) {
+          const entry = this.validators.get(validators2);
+          if (entry) {
+            resolved.push(typeof entry === "function" ? entry(schema) : entry);
+          }
+        } else {
+          console.warn(`[schemx] 未找到名为 "${validators2}" 的校验规则`);
+        }
+      } else {
+        if (validators2) resolved.push(validators2);
+      }
+    }
+    return resolved;
+  }
+  /**
+   * 检查 validators 是否已注册。
+   *
+   * @param name - validators 名称
+   * @returns 是否存在
+   *
+   * @example
+   * ```typescript
+   * validatorRegistry.has('phone')   // => true
+   * validatorRegistry.has('custom')  // => false
+   * ```
+   */
+  has(name) {
+    return this.validators.has(name);
+  }
+  /**
+   * 移除校验规则。
+   *
+   * @param name - validators 名称
+   * @returns 是否成功移除
+   *
+   * @example
+   * ```typescript
+   * validatorRegistry.unregister('phone') // => true
+   * ```
+   */
+  unregister(name) {
+    return this.validators.delete(name);
+  }
+  /**
+   * 获取所有已注册的 validators 名称。
+   *
+   * @returns validators 名称数组
+   *
+   * @example
+   * ```typescript
+   * validatorRegistry.getNames() // => ['phone', 'email', 'idCard']
+   * ```
+   */
+  getNames() {
+    return Array.from(this.validators.keys());
+  }
+  /**
+   * 清除所有已注册的规则。
+   *
+   * @example
+   * ```typescript
+   * validatorRegistry.clear()
+   * validatorRegistry.size() // => 0
+   * ```
+   */
+  clear() {
+    this.validators.clear();
+  }
+  /**
+   * 获取已注册 validators 数量。
+   *
+   * @returns validators 数量
+   *
+   * @example
+   * ```typescript
+   * validatorRegistry.size() // => 3
+   * ```
+   */
+  size() {
+    return this.validators.size;
+  }
+}
+function createValidatorsRegistry() {
+  return new ValidatorsRegistry();
+}
+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";
+}
+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;
+    }
+    if (schema && "key" in schema && schema.key) {
+      this.schemaKey = schema.key;
+    }
+  }
+}
+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);
+    }
+    descriptors.push(descriptor);
+  }
+  return descriptors;
+}
+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 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 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);
+  }
+  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;
+  }
+  if (mergedReadonly) {
+    normalizedSchema.contentAlign = "right";
+    normalizedSchema.labelPosition = "left";
+  }
+  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}`;
+  }
+  return existingplaceholder;
+}
+const isFieldDescriptor = (descriptor) => {
+  return descriptor.type === "field";
+};
+const isGroupDescriptor = (descriptor) => {
+  return descriptor.type === "group";
+};
+const isDependencyDescriptor = (descriptor) => {
+  return descriptor.type === "dependency";
+};
+function createFieldModel(descriptor) {
+  return {
+    snapshot: createSignal(createFieldModelSnapshot(descriptor))
+  };
+}
+function updateFieldModel(model, descriptor, resolved) {
+  const nextSnapshot = createFieldModelSnapshot(descriptor, resolved);
+  if (isSameFieldModelSnapshot(model.snapshot.peek(), nextSnapshot)) {
+    return;
+  }
+  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);
+}
+function isSameArrayOrValue(current, next) {
+  if (current === next) {
+    return true;
+  }
+  if (!Array.isArray(current) || !Array.isArray(next)) {
+    return false;
+  }
+  return current.length === next.length && current.every((value, index) => value === next[index]);
+}
+function isShallowEqualRecord(current, next) {
+  if (current === next) {
+    return true;
+  }
+  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]);
+}
+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) {
+    return;
+  }
+  let version = 0;
+  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);
+      })
+    );
+  });
+  scope.add(() => {
+    version += 1;
+    dispose();
+  });
+}
+async function resolveDependencies(dependencies, base, formApi) {
+  const values = formApi.getValues();
+  const [resolvedProps] = await Promise.all([
+    resolveDependenciesProps(dependencies, base, values, formApi),
+    runDependenciesTrigger(dependencies, values, formApi)
+  ]);
+  return resolvedProps;
+}
+async function runDependenciesTrigger(dependencies, values, formApi) {
+  if (!dependencies.trigger) {
+    return;
+  }
+  try {
+    await dependencies.trigger(values, formApi);
+  } catch (error) {
+    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 resolveCondition(formApi, condition, formValues, defaultValue) {
+  try {
+    const result = await condition(formValues, formApi);
+    return result ?? defaultValue;
+  } catch (error) {
+    console.error("[schemx] 解析动态属性时发生错误:", error);
+    return defaultValue;
+  }
+}
+function createDependencyEffect(options) {
+  var _a;
+  const { node, descriptor, context } = options;
+  const resourceScope = options.scope ?? node.scope.child();
+  (_a = node.dependencySlot) == null ? void 0 : _a.dispose();
+  const slot = {
+    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;
+          }
+        }
+      })()
+    );
+  };
+  slot.dispose = () => {
+    var _a2;
+    slot.version.value += 1;
+    (_a2 = slot.abortController.value) == null ? void 0 : _a2.abort();
+    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;
+    }
+    if (node.dependencyResourceScope === resourceScope) {
+      node.dependencyResourceScope = null;
+    }
+  });
+  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);
+  });
+  return slot;
+}
+function setupTriggerSubscription(triggers, formApi, run, scope) {
+  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);
+        });
+      });
+    }
+    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);
+  }
+  unregister(name, node) {
+    const key = name;
+    const current = this.fields.get(key);
+    if (node && (current == null ? void 0 : current.node) !== node) {
+      return;
+    }
+    this.fields.delete(key);
+  }
+  get(name) {
+    const key = name;
+    return this.fields.get(key);
+  }
+  list() {
+    return Array.from(this.fields.values());
+  }
+}
+function createFieldRegistry() {
+  return new RuntimeFieldRegistry();
+}
+function createValidationEffect(options) {
+  const { name, fieldModel, scope, context } = options;
+  const taskScheduler = context.scheduler;
+  const registered = createSignal(false);
+  const validating = createSignal(false);
+  let registrationVersion = 0;
+  const readValidationProps = () => {
+    const snapshot = fieldModel.snapshot.value;
+    return {
+      visible: snapshot.visible,
+      readonly: snapshot.readonly,
+      disabled: snapshot.disabled,
+      label: snapshot.label,
+      rules: snapshot.rules
+    };
+  };
+  const applyRegistration = (snapshot) => {
+    const { visible, readonly, disabled, label, rules } = snapshot;
+    if (!visible || readonly || disabled || !rules) {
+      context.instance.unregisterRules(name);
+      context.instance.setFieldError(name, []);
+      registered.value = false;
+      return;
+    }
+    context.instance.registerRules(name, rules, `${label}为必填项`);
+    registered.value = true;
+  };
+  const scheduleRegistration = (snapshot) => {
+    const currentVersion = ++registrationVersion;
+    taskScheduler.schedule({
+      id: `validation:${String(name)}`,
+      priority: "post",
+      scope,
+      run: () => {
+        if (scope.disposed || currentVersion !== registrationVersion) {
+          return;
+        }
+        applyRegistration(snapshot);
+      }
+    });
+  };
+  scope.add(() => {
+    registrationVersion += 1;
+    context.instance.unregisterRules(name);
+    context.instance.setFieldError(name, []);
+    registered.value = false;
+  });
+  const disposeEffect = createSignalEffect(() => {
+    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 createLifecycleBus(initialListener) {
+  const listeners = /* @__PURE__ */ new Set();
+  if (initialListener) {
+    listeners.add(initialListener);
+  }
+  const emit = (run, ...args) => {
+    for (const listener of Array.from(listeners)) {
+      run(listener, ...args);
+    }
+  };
+  const on = (listener) => {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  };
+  const emitMount = (node) => {
+    emit((listener, currentNode) => {
+      var _a, _b;
+      (_a = listener.mount) == null ? void 0 : _a.call(listener, currentNode);
+      (_b = listener.mounted) == null ? void 0 : _b.call(listener, currentNode);
+    }, node);
+  };
+  const emitBeforeMount = (node) => {
+    emit((listener, currentNode) => {
+      var _a;
+      (_a = listener.beforeMount) == null ? void 0 : _a.call(listener, currentNode);
+    }, node);
+  };
+  const emitUpdate = (node, previousNode) => {
+    emit(
+      (listener, currentNode, currentPreviousNode) => {
+        var _a;
+        (_a = listener.update) == null ? void 0 : _a.call(listener, currentNode, currentPreviousNode);
+      },
+      node,
+      previousNode
+    );
+  };
+  const emitBeforeUpdate = (node, previousNode) => {
+    emit(
+      (listener, currentNode, currentPreviousNode) => {
+        var _a;
+        (_a = listener.beforeUpdate) == null ? void 0 : _a.call(listener, currentNode, currentPreviousNode);
+      },
+      node,
+      previousNode
+    );
+  };
+  const emitUpdated = (node, previousNode) => {
+    emit(
+      (listener, currentNode, currentPreviousNode) => {
+        var _a;
+        (_a = listener.updated) == null ? void 0 : _a.call(listener, currentNode, currentPreviousNode);
+      },
+      node,
+      previousNode
+    );
+  };
+  const emitBeforeUnmount = (node) => {
+    emit((listener, currentNode) => {
+      var _a;
+      (_a = listener.beforeUnmount) == null ? void 0 : _a.call(listener, currentNode);
+    }, node);
+  };
+  const emitUnmount = (node) => {
+    emit((listener, currentNode) => {
+      var _a, _b;
+      (_a = listener.unmount) == null ? void 0 : _a.call(listener, currentNode);
+      (_b = listener.unmounted) == null ? void 0 : _b.call(listener, currentNode);
+    }, node);
+  };
+  const clear = () => {
+    listeners.clear();
+  };
+  return {
+    on,
+    emitMount,
+    emitBeforeMount,
+    emitUpdate,
+    emitBeforeUpdate,
+    emitUpdated,
+    emitBeforeUnmount,
+    emitUnmount,
+    clear
+  };
+}
+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 = [];
+  const childScopes = [];
+  const add = (cleanup) => {
+    if (disposed) {
+      runCleanup(cleanup);
+      return createDisposedHandle();
+    }
+    const record = {
+      cleanup,
+      disposed: false
+    };
+    cleanupRecords.push(record);
+    const disposeCleanup = () => {
+      if (record.disposed) {
+        return;
+      }
+      record.disposed = true;
+      removeItem(cleanupRecords, record);
+      runCleanup(record.cleanup);
+    };
+    return {
+      get disposed() {
+        return record.disposed;
+      },
+      dispose: disposeCleanup
+    };
+  };
+  const child = () => {
+    const childScope = createScope();
+    childScopes.push(childScope);
+    childScope.add(() => {
+      removeItem(childScopes, childScope);
+    });
+    return childScope;
+  };
+  const disposeScope = () => {
+    if (disposed) {
+      return;
+    }
+    disposed = true;
+    for (const childScope of childScopes.slice().reverse()) {
+      childScope.dispose();
+    }
+    childScopes.length = 0;
+    for (const record of cleanupRecords.slice().reverse()) {
+      if (!record.disposed) {
+        record.disposed = true;
+        runCleanup(record.cleanup);
+      }
+    }
+    cleanupRecords.length = 0;
+  };
+  return {
+    get disposed() {
+      return disposed;
+    },
+    add,
+    child,
+    dispose: disposeScope
+  };
+}
+const createDisposedHandle = () => {
+  return {
+    disposed: true,
+    dispose: noop
+  };
+};
+const noop = () => {
+};
+const removeItem = (items, item) => {
+  const index = items.indexOf(item);
+  if (index >= 0) {
+    items.splice(index, 1);
+  }
+};
+const runCleanup = (cleanup) => {
+  try {
+    cleanup();
+  } catch (error) {
+    reportRuntimeCleanupError(error);
+  }
+};
+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;
+  }
+  /**
+   * 创建透明根 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: []
+    };
+  }
+  /**
+   * 根据 descriptor 创建单个未挂载 RuntimeNode。
+   *
+   * @param descriptor - 编译后的表单节点描述符。
+   * @param parent - 新 RuntimeNode 所属的容器 RuntimeNode。
+   */
+  create(descriptor, parent) {
+    if (descriptor.type === "field") {
+      return this.createField(descriptor, parent);
+    }
+    if (descriptor.type === "group") {
+      return this.createGroup(descriptor, parent);
+    }
+    if (descriptor.type === "dependency") {
+      return this.createDependency(descriptor, parent);
+    }
+    throwUnknownDescriptor(descriptor);
+  }
+  /**
+   * 挂载单个 RuntimeNode 的运行期资源。
+   *
+   * @param node - 要挂载的 RuntimeNode。
+   *
+   * @remarks
+   * Group RuntimeNode 只表示结构，不会创建领域资源；Field 和 Dependency 会在这里
+   * 创建各自的模型、effect 与资源 scope。
+   */
+  mount(node) {
+    if (!hasDescriptor(node)) {
+      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;
+    }
+    node.mounted.value = true;
+    this.lifecycleBus.emitMount(node);
+  }
+  /**
+   * 更新单个 RuntimeNode 的 descriptor 快照和运行期资源。
+   *
+   * @param node - 要更新的 RuntimeNode。
+   * @param next - 更新后的表单 descriptor。
+   *
+   * @remarks
+   * descriptor 快照会先写入 RuntimeNode，再由具体 update 分支决定复用还是重启资源。
+   * 结构层面的 children reconcile 不在这里处理。
+   */
+  update(node, next) {
+    if (!hasDescriptor(node)) {
+      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;
+      }
+    }
+  }
+  /**
+   * 卸载单个 RuntimeNode 的运行期资源。
+   *
+   * @param node - 要卸载的 RuntimeNode。
+   *
+   * @remarks
+   * 这个方法不递归销毁子节点；需要销毁整棵子树时使用 `disposeTree`。
+   */
+  unmount(node) {
+    if (!hasDescriptor(node)) {
+      return;
+    }
+    switch (node.type) {
+      case "field":
+        this.unmountField(node);
+        break;
+      case "group":
+        this.unmountGroup(node);
+        break;
+      case "dependency":
+        this.unmountDependency(node);
+        break;
+    }
+    node.mounted.value = false;
+  }
+  /**
+   * 递归销毁 RuntimeNode 子树。
+   *
+   * @param node - 要销毁的子树根 RuntimeNode。
+   *
+   * @remarks
+   * 销毁顺序是：标记 disposed、递归销毁 runtime 子节点、卸载自身领域资源、
+   * 释放 RuntimeNode scope、断开 parent。这样可以确保子资源先于父资源释放。
+   */
+  disposeTree(node) {
+    if (node.disposed.value) {
+      return;
+    }
+    if (node.type !== "root") {
+      this.lifecycleBus.emitBeforeUnmount(node);
+    }
+    node.disposed.value = true;
+    if (isContainerRuntimeNode(node)) {
+      for (const child of getChildRuntimeNodes(node)) {
+        this.disposeTree(child);
+      }
+      setChildRuntimeNodes(node, []);
+    }
+    this.unmount(node);
+    node.scope.dispose();
+    node.parent = null;
+    if (node.type !== "root") {
+      this.lifecycleBus.emitUnmount(node);
+    }
+  }
+  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),
+      descriptor,
+      fieldModel,
+      fieldResourceScope: null,
+      fieldDependenciesScope: null
+    };
+    return node;
+  }
+  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;
+  }
+  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),
+      descriptor,
+      dependencySlot: null,
+      dependencyResourceScope: null,
+      dynamicChildNodes: []
+    };
+    return node;
+  }
+  mountField(node) {
+    const resourceScope = node.scope.child();
+    const model = node.fieldModel;
+    if (!model) {
+      return;
+    }
+    this.initializeFieldValue(node);
+    node.fieldResourceScope = resourceScope;
+    this.fieldRegistry.register({
+      name: node.descriptor.name,
+      node,
+      model
+    });
+    resourceScope.add(() => {
+      this.fieldRegistry.unregister(node.descriptor.name, node);
+      if (node.fieldResourceScope === resourceScope) {
+        node.fieldResourceScope = null;
+      }
+    });
+    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) {
+      return;
+    }
+    const values = {};
+    setByPath(values, name, schema.initialValue);
+    this.instance.setInitialValues(values);
+    this.instance.setFieldValue(name, schema.initialValue);
+  }
+  mountGroup(_node) {
+  }
+  mountDependency(node) {
+    createDependencyEffect({
+      node,
+      descriptor: node.descriptor,
+      context: this.context
+    });
+  }
+  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
+      });
+      this.mountOrRestartFieldDependencies(node, model);
+      return;
+    }
+    this.unmountField(node);
+    this.mountField(node);
+  }
+  updateGroup(_node, _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);
+    }
+  }
+  mountFieldValidation(node, model = node.fieldModel, scope = node.fieldResourceScope) {
+    if (!model || !scope) {
+      return;
+    }
+    createValidationEffect({
+      name: node.descriptor.name,
+      fieldModel: model,
+      context: this.context,
+      scope
+    });
+  }
+  mountOrRestartFieldDependencies(node, model = node.fieldModel) {
+    var _a;
+    (_a = node.fieldDependenciesScope) == null ? void 0 : _a.dispose();
+    if (!model || !node.descriptor.dependencies) {
+      node.fieldDependenciesScope = null;
+      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) {
+  }
+  unmountDependency(node) {
+    var _a;
+    (_a = node.dependencyResourceScope) == null ? void 0 : _a.dispose();
+    node.dependencyResourceScope = null;
+    node.dependencySlot = null;
+  }
+}
+function createRuntimeNodeManager(context) {
+  return new DefaultRuntimeNodeManager(context);
+}
+function isSameNamePathList(a2, b2) {
+  if (a2.length !== b2.length) {
+    return false;
+  }
+  return a2.every((name, index) => name === b2[index]);
+}
+function createPreviousRuntimeNodeSnapshot(node) {
+  return { ...node };
+}
+function throwUnknownDescriptor(descriptor) {
+  throw new Error(`unknown type: ${descriptor.type ?? "unknown"}`);
+}
+function throwUnexpectedDescriptor(node, descriptor) {
+  throw new Error(
+    `unexpected descriptor type: node ${node.type} cannot update with ${descriptor.type}`
+  );
+}
+const PRIORITY_ORDER = ["sync", "pre", "normal", "post"];
+function createScheduler() {
+  const queues = new Map(
+    PRIORITY_ORDER.map((priority) => [priority, /* @__PURE__ */ new Map()])
+  );
+  const idleResolvers = /* @__PURE__ */ new Set();
+  let pendingAsync = 0;
+  let disposed = false;
+  let currentFlush = null;
+  const flush = async () => {
+    if (disposed) {
+      return;
+    }
+    if (currentFlush) {
+      return currentFlush;
+    }
+    currentFlush = flushOnce().finally(() => {
+      currentFlush = null;
+      notifyIdleIfNeeded();
+    });
+    return currentFlush;
+  };
+  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;
+      }
+      try {
+        const result = task.run();
+        if (isPromiseLike(result)) {
+          await track(result);
+        }
+      } catch (error) {
+        (_b = task.onError) == null ? void 0 : _b.call(task, error);
+      }
+    }
+  };
+  const schedule = (task) => {
+    var _a, _b;
+    if (disposed || ((_a = task.scope) == null ? void 0 : _a.disposed)) {
+      return;
+    }
+    (_b = queues.get(task.priority)) == null ? void 0 : _b.set(task.id, task);
+    queueMicrotask(() => void flush());
+  };
+  const takeBatch = () => {
+    const batch = [];
+    for (const priority of PRIORITY_ORDER) {
+      const queue = queues.get(priority);
+      if (!queue) {
+        continue;
+      }
+      batch.push(...queue.values());
+      queue.clear();
+    }
+    return batch;
+  };
+  const track = async (promise) => {
+    pendingAsync += 1;
+    try {
+      return await promise;
+    } finally {
+      pendingAsync -= 1;
+      notifyIdleIfNeeded();
+    }
+  };
+  const whenIdle = (timeout = 1e4) => {
+    if (isIdle()) {
+      return Promise.resolve(true);
+    }
+    return new Promise((resolve) => {
+      const timeoutId = globalThis.setTimeout(() => {
+        idleResolvers.delete(resolve);
+        resolve(false);
+      }, timeout);
+      idleResolvers.add((idle) => {
+        globalThis.clearTimeout(timeoutId);
+        resolve(idle);
+      });
+    });
+  };
+  const isIdle = () => {
+    return !currentFlush && pendingAsync === 0 && !hasQueuedTasks();
+  };
+  const hasQueuedTasks = () => {
+    return Array.from(queues.values()).some((queue) => queue.size > 0);
+  };
+  const notifyIdleIfNeeded = () => {
+    if (!isIdle()) {
+      return;
+    }
+    const resolvers = Array.from(idleResolvers);
+    idleResolvers.clear();
+    resolvers.forEach((resolve) => resolve(true));
+  };
+  const dispose = () => {
+    disposed = true;
+    queues.forEach((queue) => queue.clear());
+    notifyIdleIfNeeded();
+  };
+  return {
+    schedule,
+    flush,
+    whenIdle,
+    track,
+    dispose
+  };
+}
+const isPromiseLike = (value) => {
+  return value !== null && typeof value === "object" && "then" in value && typeof value.then === "function";
+};
+class StoreImpl {
+  /**
+   * 创建 Store 实例。
+   *
+   * 对 initialValues 进行深拷贝，确保内部状态与外部引用隔离。
+   * 为每个初始字段路径创建对应的 reactive value。
+   *
+   * @param options - 配置选项
+   */
+  constructor(options = {}) {
+    __publicField(this, "fieldSignals", createFieldSignalMap());
+    __publicField(this, "initialValues");
+    const initialValues = options.initialValues ?? {};
+    this.initialValues = cloneDeep(initialValues);
+    const paths = collectObjectPathsByLeaf(initialValues);
+    for (const path of paths) {
+      const value = getByPath(initialValues, path);
+      this.fieldSignals.set(
+        path,
+        createFieldSignal({
+          value,
+          initialValue: value
+        })
+      );
+    }
+  }
+  getOrCreateFieldSignal(path) {
+    const initialValue = getByPath(this.initialValues, path);
+    let signal = this.fieldSignals.peek(path);
+    if (!signal) {
+      signal = createFieldSignal({
+        value: initialValue,
+        initialValue
+      });
+      this.fieldSignals.set(path, signal);
+    }
+    return signal;
+  }
+  /**
+   * 获取指定路径的字段值。
+   *
+   * 读取对应 reactive value，在 effect 中使用时自动收集依赖。
+   *
+   * @param path - 字段路径，支持嵌套路径如 'user.name'
+   * @returns 字段当前值
+   *
+   * @example
+   * ```typescript
+   * store.getFieldValue('name')         // => 'John'
+   * store.getFieldValue('user.address') // => { city: 'Beijing', zip: '100000' }
+   * ```
+   */
+  getFieldValue(path) {
+    const signal = this.fieldSignals.get(path);
+    return signal == null ? void 0 : signal.value.value;
+  }
+  /**
+   * 设置指定路径的字段值。
+   *
+   * 直接写入对应 reactive value，自动触发依赖它的 effect。
+   *
+   * @param path - 字段路径
+   * @param value - 要设置的值
+   *
+   * @example
+   * ```typescript
+   * store.setFieldValue('name', 'Jane')
+   * store.setFieldValue('user.age', 30)
+   * ```
+   */
+  setFieldValue(path, value) {
+    const signal = this.getOrCreateFieldSignal(path);
+    signal.setValue(value);
+    signal.setTouched(!isEqual(value, signal.initialValue.peek()));
+  }
+  getFieldsValue(paths) {
+    const result = {};
+    const pathsArr = paths ?? this.fieldSignals.keys();
+    for (const path of pathsArr) {
+      setByPath(result, path, this.getFieldValue(path));
+    }
+    return result;
+  }
+  /**
+   * 批量设置多个字段的值。
+   *
+   * 批量设置多个字段；每个字段写入都会更新对应 FieldSignal。
+   *
+   * @param values - 要设置的字段值对象
+   *
+   * @example
+   * ```typescript
+   * store.setFieldsValue({ name: 'Bob', age: 30 })
+   * ```
+   */
+  setFieldsValue(values) {
+    const paths = collectObjectPathsByLeaf(values);
+    batchUpdates(() => {
+      for (const path of paths) {
+        this.setFieldValue(path, getByPath(values, path));
+      }
+    });
+  }
+  /**
+   * 获取单个字段值的快照。
+   *
+   * 使用 signal.peek() 避免收集依赖，返回深拷贝的值。
+   *
+   * @param path - 字段路径
+   *
+   * @returns 该字段当前值的深拷贝
+   *
+   * @example
+   * ```typescript
+   * const name = store.getFieldSnapshot('name') // => 'John'（深拷贝）
+   * ```
+   */
+  getFieldSnapshot(path) {
+    const signal = this.fieldSignals.peek(path);
+    return signal == null ? void 0 : signal.value.peek();
+  }
+  getFieldsSnapshot(paths) {
+    const result = {};
+    const pathsArr = paths ?? this.fieldSignals.keys();
+    for (const path of pathsArr) {
+      setByPath(result, path, this.getFieldSnapshot(path));
+    }
+    return result;
+  }
+  /**
+   * 获取指定字段的初始值。
+   *
+   * @param path - 字段路径
+   * @returns 字段初始值，不存在时返回 undefined
+   *
+   * @example
+   * ```typescript
+   * store.getInitialValue('name') // => 'John'
+   * ```
+   */
+  getInitialValue(path) {
+    const signal = this.fieldSignals.peek(path);
+    if (signal) {
+      return signal.initialValue.peek();
+    }
+    return getByPath(this.initialValues, path);
+  }
+  getInitialValues(paths) {
+    if (paths === void 0) {
+      return cloneDeep(this.initialValues);
+    }
+    const result = {};
+    for (const path of paths) {
+      setByPath(result, path, getByPath(this.initialValues, path));
+    }
+    return result;
+  }
+  /**
+   * 设置指定字段的初始值。
+   *
+   * @param path - 字段路径
+   * @param value - 要设置的初始值
+   *
+   * @example
+   * ```typescript
+   * store.setInitialValue('name', 'Bob')
+   * ```
+   */
+  setInitialValue(path, value) {
+    setByPath(this.initialValues, path, value);
+    const signal = this.getOrCreateFieldSignal(path);
+    signal.setInitialValue(value);
+    signal.setTouched(!isEqual(signal.value.peek(), signal.initialValue.peek()));
+  }
+  /**
+   * 批量设置多个字段的初始值。
+   *
+   * @param values - 要设置的字段值对象
+   *
+   * @example
+   * ```typescript
+   * store.setInitialValues({ name: 'Bob', age: 30 })
+   * ```
+   */
+  setInitialValues(values) {
+    const paths = collectObjectPathsByLeaf(values);
+    if (!paths.length) return;
+    batchUpdates(() => {
+      for (const path of paths) {
+        const next = getByPath(values, path);
+        setByPath(this.initialValues, path, next);
+        const signal = this.getOrCreateFieldSignal(path);
+        signal.setInitialValue(next);
+        signal.setTouched(!isEqual(signal.value.peek(), signal.initialValue.peek()));
+      }
+    });
+  }
+  /**
+   * 检查指定字段是否被修改过。
+   *
+   * 通过深比较当前值与初始值判断。
+   *
+   * @param path - 字段路径
+   * @returns 是否与初始值不同
+   *
+   * @example
+   * ```typescript
+   * store.setFieldValue('name', 'Jane')
+   * store.isFieldTouched('name') // => true
+   * ```
+   */
+  isFieldTouched(path) {
+    var _a;
+    return ((_a = this.fieldSignals.get(path)) == null ? void 0 : _a.touched.value) ?? false;
+  }
+  isFieldsTouched(paths) {
+    const pathsArr = paths ?? [...this.fieldSignals.keys()];
+    return paths === void 0 ? pathsArr.some((path) => this.isFieldTouched(path)) : pathsArr.every((path) => this.isFieldTouched(path));
+  }
+  /**
+   * 获取所有被修改的字段路径。
+   *
+   * 遍历所有 reactive values，与初始值比较，收集不同的路径。
+   *
+   * @returns 被修改的字段路径数组
+   *
+   * @example
+   * ```typescript
+   * store.getTouchedFields() // => ['name', 'user.age']
+   * ```
+   */
+  getTouchedFields() {
+    const touchedFields = [];
+    for (const [path, signal] of this.fieldSignals.entries()) {
+      if (signal.touched.value) {
+        touchedFields.push(path);
+      }
+    }
+    return touchedFields;
+  }
+  /**
+   * 设置字段的修改状态。
+   *
+   * @param path - 字段路径
+   * @param touched - 是否被修改
+   *
+   * @example
+   * ```typescript
+   * store.setFieldTouched('name', true)
+   * ```
+   */
+  setFieldTouched(path, touched) {
+    this.getOrCreateFieldSignal(path).setTouched(touched);
+  }
+  /**
+   * 批量设置字段的修改状态。
+   *
+   * @param paths - 要设置 touched 状态的字段路径数组
+   * @param touched - 目标 touched 状态，默认 true
+   *
+   * @example
+   * ```typescript
+   * store.setFieldsTouched(['name', 'age'], true)
+   * ```
+   */
+  setFieldsTouched(paths, touched = true) {
+    batchUpdates(() => {
+      for (const path of paths) {
+        this.setFieldTouched(path, touched);
+      }
+    });
+  }
+  /**
+   * 检查单个字段是否处于操作中。
+   *
+   * 读取对应 reactive value，在 effect 中使用时自动收集依赖。
+   *
+   * @param path - 字段路径
+   * @returns 是否处于操作中
+   *
+   * @example
+   * ```typescript
+   * store.isFieldPending('avatar') // => true
+   * ```
+   */
+  isFieldPending(path) {
+    var _a;
+    return ((_a = this.fieldSignals.get(path)) == null ? void 0 : _a.pending.value) ?? false;
+  }
+  isFieldsPending(paths) {
+    const pathsArr = paths ?? [...this.fieldSignals.keys()];
+    return pathsArr.every((path) => this.isFieldPending(path));
+  }
+  /**
+   * 获取所有处于操作中的字段路径。
+   *
+   * 遍历字段 signal，收集 pending 为 true 的字段路径。
+   * 无操作中字段时返回空数组。
+   *
+   * @returns 操作中的字段路径数组
+   *
+   * @example
+   * ```typescript
+   * store.getPendingFields() // => ['avatar', 'attachment']
+   * ```
+   */
+  getPendingFields() {
+    const fields = [];
+    for (const [field, signal] of this.fieldSignals.entries()) {
+      if (signal.pending.value) {
+        fields.push({ field, message: signal.pendingMessage.peek() });
+      }
+    }
+    return fields;
+  }
+  /**
+   * 设置字段的操作中状态。
+   *
+   * 标记字段正在进行异步操作（如文件上传），
+   * 校验和提交时会检查是否有字段处于操作中状态。
+   * 取消操作中状态时删除对应 key，保持 map 干净。
+   *
+   * @param path - 字段路径
+   * @param pending - 是否处于操作中
+   * @param message - 可选的操作中提示信息。
+   *
+   * @example
+   * ```typescript
+   * store.setFieldPending('avatar', true)   // 上传开始
+   * store.setFieldPending('avatar', false)  // 上传结束
+   * ```
+   */
+  setFieldPending(path, pending, message) {
+    this.getOrCreateFieldSignal(path).setPending(pending, message);
+  }
+  /**
+   * 批量设置字段的操作中状态。
+   *
+   * @param paths - 要设置 pending 状态的字段路径数组
+   * @param pending - 目标 pending 状态，默认 true
+   * @param message - 可选的操作中提示信息。
+   *
+   * @example
+   * ```typescript
+   * store.setFieldsPending(['name', 'age'], true)
+   * ```
+   */
+  setFieldsPending(paths, pending = true, message) {
+    batchUpdates(() => {
+      for (const path of paths) {
+        this.setFieldPending(path, pending, message);
+      }
+    });
+  }
+  /**
+   * 重置单个字段到初始值。
+   *
+   * @param path - 要重置的字段路径。
+   *
+   * @example
+   * ```typescript
+   * store.resetField('name')
+   * ```
+   */
+  resetField(path) {
+    this.getOrCreateFieldSignal(path).reset();
+  }
+  /**
+   * 批量重置指定字段到初始值。
+   *
+   * @param paths - 要重置的字段路径数组。
+   *
+   * @example
+   * ```typescript
+   * store.resetFields(['name', 'age'])
+   * ```
+   */
+  resetFields(paths) {
+    batchUpdates(() => {
+      for (const path of paths) {
+        this.getOrCreateFieldSignal(path).reset();
+      }
+    });
+  }
+  /**
+   * 重置表单到初始状态（diff 式更新）。
+   *
+   * 不传参时恢复到构造时的初始值，传入 values 时同时更新初始值。
+   * 对比新旧路径集合：复用已有字段 signal、删除多余字段 signal、
+   * 创建新字段 signal。
+   *
+   * @param values - 可选的新初始值；传入后会同时更新 initialValues baseline。
+   *
+   * @example
+   * ```typescript
+   * store.reset()                              // 恢复到构造时的初始值
+   * store.reset({ name: 'New', age: 0 })       // 重置并更新初始值
+   * ```
+   */
+  reset(values) {
+    const resetValues = cloneDeep(values ?? this.initialValues);
+    const nextPaths = collectObjectPathsByLeaf(resetValues);
+    const nextPathSet = new Set(nextPaths);
+    batchUpdates(() => {
+      for (const path of this.fieldSignals.keys()) {
+        if (!nextPathSet.has(path)) {
+          this.fieldSignals.delete(path);
+        }
+      }
+      for (const path of nextPaths) {
+        const next = getByPath(resetValues, path);
+        setByPath(this.initialValues, path, next);
+        const signal = this.fieldSignals.peek(path);
+        if (signal) {
+          signal.setInitialValue(next);
+          signal.reset(next);
+        } else {
+          this.fieldSignals.set(
+            path,
+            createFieldSignal({
+              value: next,
+              initialValue: next
+            })
+          );
+        }
+      }
+    });
+  }
+  /**
+   * 销毁 Store 实例。
+   *
+   * 清理所有字段 signal，释放资源。
+   *
+   * @example
+   * ```typescript
+   * store.destroy()
+   * ```
+   */
+  destroy() {
+    this.fieldSignals.clear();
+  }
+}
+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) {
+  let rootDisposed = false;
+  const rootScope = root.scope;
+  const disposeHandle = rootScope.add(() => {
+    rootDisposed = true;
+  });
+  const disposeEffect = createDebouncedSignalEffect(
+    () => {
+      void revision.revision.value;
+      return rootDisposed ? [] : buildViewSchemas(root);
+    },
+    (viewSchemas) => {
+      try {
+        onChange(viewSchemas);
+      } catch (error) {
+        console.error("[subscribeViewSchemas] onChange error:", error);
+      }
+    },
+    16,
+    { immediate: true, edges: ["leading", "trailing"] }
+  );
+  const unsubscribe = () => {
+    disposeEffect();
+    disposeHandle.dispose();
+    rootDisposed = false;
+  };
+  return unsubscribe;
+}
+function createViewRevision() {
+  const revision = createSignal(0);
+  const bump = () => {
+    revision.value += 1;
+  };
+  return {
+    revision,
+    bump
+  };
+}
+class CreateForm {
+  constructor(options = {}) {
+    __publicField(this, "context");
+    __publicField(this, "callbacks");
+    __publicField(this, "store");
+    __publicField(this, "rendererRegistry");
+    __publicField(this, "validatorRegistry");
+    __publicField(this, "validator");
+    __publicField(this, "root");
+    __publicField(this, "scheduler");
+    __publicField(this, "viewRevision");
+    __publicField(this, "reconciler");
+    __publicField(this, "runtimeNodeManager");
+    __publicField(this, "fieldRegistry");
+    __publicField(this, "scope", createScope());
+    __publicField(this, "schemas");
+    __publicField(this, "disposed", false);
+    __publicField(this, "lifecycleBus");
+    __publicField(this, "getFormInstance", () => {
+      return {
+        setFieldValue: this.store.setFieldValue.bind(this.store),
+        setFieldsValue: this.store.setFieldsValue.bind(this.store),
+        getFieldValue: this.store.getFieldValue.bind(this.store),
+        getFieldsValue: this.store.getFieldsValue.bind(this.store),
+        getFieldSnapshot: this.store.getFieldSnapshot.bind(this.store),
+        getFieldsSnapshot: this.store.getFieldsSnapshot.bind(this.store),
+        getInitialValue: this.store.getInitialValue.bind(this.store),
+        getInitialValues: this.store.getInitialValues.bind(this.store),
+        setInitialValues: this.store.setInitialValues.bind(this.store),
+        isFieldTouched: this.store.isFieldTouched.bind(this.store),
+        setFieldTouched: this.store.setFieldTouched.bind(this.store),
+        getTouchedFields: this.store.getTouchedFields.bind(this.store),
+        setFieldPending: this.store.setFieldPending.bind(this.store),
+        isFieldPending: this.store.isFieldPending.bind(this.store),
+        getPendingFields: this.store.getPendingFields.bind(this.store),
+        validateField: this.validateField.bind(this),
+        validate: this.validate.bind(this),
+        getFieldError: this.validator.getFieldError.bind(this.validator),
+        setFieldError: this.validator.setFieldError.bind(this.validator),
+        resetFields: this.store.resetFields.bind(this.store),
+        reset: this.reset.bind(this),
+        submit: this.submit.bind(this),
+        registerRules: this.register.bind(this),
+        unregisterRules: this.validator.unregister.bind(this.validator),
+        effect: this.effect.bind(this),
+        batch: this.batch.bind(this),
+        setSchemas: this.setSchemas.bind(this),
+        updateSchemas: this.updateSchemas.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),
+        getRenderer: this.rendererRegistry.getRenderer.bind(this.rendererRegistry),
+        registerRenderer: this.rendererRegistry.register.bind(this.rendererRegistry),
+        hasRenderer: this.rendererRegistry.hasRenderer.bind(this.rendererRegistry),
+        getValidator: this.validatorRegistry.get.bind(this.validatorRegistry),
+        registerValidator: this.validatorRegistry.register.bind(this.validatorRegistry),
+        hasValidator: this.validatorRegistry.has.bind(this.validatorRegistry),
+        destroy: this.destroy.bind(this)
+      };
+    });
+    __publicField(this, "getFormApi", () => {
+      return {
+        setValue: this.store.setFieldValue.bind(this.store),
+        setValues: this.store.setFieldsValue.bind(this.store),
+        getValue: this.store.getFieldValue.bind(this.store),
+        getValues: this.store.getFieldsValue.bind(this.store),
+        getSnapshots: this.store.getFieldsSnapshot.bind(this.store),
+        setPending: this.store.setFieldPending.bind(this.store),
+        isPending: this.store.isFieldPending.bind(this.store),
+        setTouched: this.store.setFieldTouched.bind(this.store),
+        isTouched: this.store.isFieldTouched.bind(this.store),
+        getError: this.validator.getFieldError.bind(this.validator),
+        setError: this.validator.setFieldError.bind(this.validator),
+        resetFields: this.store.resetFields.bind(this.store),
+        reset: this.reset.bind(this),
+        validateField: this.validateField.bind(this),
+        validate: this.validate.bind(this)
+      };
+    });
+    __publicField(this, "validate", withLock(async () => {
+      const pendingFields = this.store.getPendingFields();
+      if (pendingFields.length > 0) {
+        const defaultMessage = `存在正在操作中的字段: ${pendingFields.map((i2) => i2.field).join(", ")}，请等待完成后再提交`;
+        console.warn(`[schemx] ${defaultMessage}`);
+        return {
+          ok: false,
+          error: {
+            errors: pendingFields.map(({ field, message }) => {
+              const _message = message.length ? message : ["字段正在处理中，请稍后重试"];
+              this.validator.setFieldError(field, _message);
+              return {
+                field,
+                message: _message
+              };
+            }),
+            values: this.store.getFieldsSnapshot()
+          }
+        };
+      }
+      const result = await this.validator.validate(this.store.getFieldsValue());
+      return result;
+    }));
+    __publicField(this, "submit", withLock(async () => {
+      var _a2, _b2, _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));
+      } else {
+        (_d = (_c = this.callbacks).onFinishFailed) == null ? void 0 : _d.call(_c, result.error);
+      }
+    }));
+    __publicField(this, "commitChildren", (parentNode, descriptors) => {
+      const changed = this.reconciler.reconcileChildren(parentNode, descriptors);
+      if (changed) {
+        this.viewRevision.bump();
+      }
+    });
+    var _a, _b;
+    const {
+      schemas: schemasInput,
+      initialValues = {},
+      modelValue,
+      rendererRegistry: rendererRegistry2,
+      defaultRendererType,
+      validatorRegistry: validatorRegistry2,
+      ...restOptions
+    } = options;
+    this.callbacks = {
+      onValuesChange: options.onValuesChange,
+      onFinish: options.onFinish,
+      onFinishFailed: options.onFinishFailed,
+      onFieldsChange: options.onFieldsChange
+    };
+    this.rendererRegistry = rendererRegistry2 ?? createRendererRegistry(defaultRendererType);
+    this.validatorRegistry = validatorRegistry2 ?? createValidatorsRegistry();
+    this.validator = createValidator();
+    this.store = createStore({
+      initialValues: { ...initialValues, ...modelValue ?? {} }
+    });
+    this.validatorRegistry.registerAll({
+      required: createRequiredRule,
+      selectRequired: createSelectRequiredRule,
+      uploadRequired: createUploadRequiredRule
+    });
+    this.lifecycleBus = createLifecycleBus();
+    this.scheduler = createScheduler();
+    this.viewRevision = createViewRevision();
+    this.fieldRegistry = createFieldRegistry();
+    this.context = {
+      defaultProps: pick(restOptions, defaultConfigKey),
+      instance: this.getFormInstance(),
+      formApi: this.getFormApi(),
+      scheduler: this.scheduler,
+      lifecycleBus: this.lifecycleBus,
+      fieldRegistry: this.fieldRegistry,
+      commitChildren: this.commitChildren
+    };
+    this.runtimeNodeManager = createRuntimeNodeManager(this.context);
+    this.reconciler = createReconciler(this.runtimeNodeManager);
+    this.root = this.runtimeNodeManager.createRoot();
+    if (options.lifecycleHooks) {
+      this.lifecycleBus.on(options.lifecycleHooks);
+    }
+    this.schemas = isSchemxSchemas(schemasInput) ? schemasInput : createSchemas(schemasInput ?? []);
+    this.applySchemas(this.schemas.peek());
+    const schemasDisposer = this.schemas.subscribe((nextSchemas) => {
+      this.applySchemas(nextSchemas);
+    });
+    this.scope.add(schemasDisposer);
+    if (((_a = this.callbacks) == null ? void 0 : _a.onValuesChange) || ((_b = this.callbacks) == null ? void 0 : _b.onFieldsChange)) {
+      let prevSnapshot = this.store.getFieldsSnapshot();
+      const valuesChangeDisposer = createSignalEffect(() => {
+        var _a2, _b2, _c, _d;
+        const latestValues = this.store.getFieldsValue();
+        const latestSnapshot = this.store.getFieldsSnapshot();
+        const changedValues = diff(latestSnapshot, prevSnapshot);
+        const changedPaths = collectObjectPathsByLeaf(changedValues);
+        if (changedPaths.length > 0) {
+          (_b2 = (_a2 = this.callbacks).onValuesChange) == null ? void 0 : _b2.call(_a2, changedValues, latestSnapshot);
+          (_d = (_c = this.callbacks).onFieldsChange) == null ? void 0 : _d.call(
+            _c,
+            changedPaths,
+            collectObjectPathsByLeaf(latestValues)
+          );
+        }
+        prevSnapshot = latestSnapshot;
+      });
+      this.scope.add(valuesChangeDisposer);
+    }
+  }
+  /**
+   * 注册字段校验规则
+   */
+  register(path, rules, defaultMessage) {
+    const resolvedRules = [];
+    const node = findFieldRuntimeNode(this.root, path);
+    const schema = node == null ? void 0 : node.descriptor.schema;
+    this.validator.unregister(path);
+    const schemaWithRules = {
+      ...schema,
+      rules
+    };
+    resolvedRules.push(
+      ...this.validatorRegistry.resolveValidatorsBySchema(schemaWithRules)
+    );
+    if (resolvedRules.length > 0) {
+      this.validator.register(path, resolvedRules, defaultMessage);
+    }
+  }
+  /**
+   * 校验指定字段
+   */
+  async validateField(name) {
+    const result = await this.validator.validateField(name, this.store.getFieldsValue());
+    return result;
+  }
+  /**
+   * 重置整个表单到初始值
+   */
+  reset() {
+    this.store.reset();
+    this.validator.reset();
+  }
+  /**
+   * 创建 reactive effect。
+   *
+   * 回调内调用 getFieldValue / getFieldError 时自动追踪依赖，
+   * 跨越 store 和 validator 的 reactive maps。
+   * dispose 函数由 createForm 层面统一管理，destroy 时清理。
+   */
+  effect(fn) {
+    const dispose = createSignalEffect(fn);
+    const handle = this.scope.add(dispose);
+    return () => {
+      handle.dispose();
+    };
+  }
+  /**
+   * 批量更新，合并多次 reactive 写入。
+   *
+   * 将多次 reactive 写入合并为一次 effect 触发，
+   * 跨越 store 和 validator 的 reactive maps。
+   */
+  batch(fn) {
+    batchUpdates(fn);
+  }
+  /**
+   * 替换 root schemas。
+   */
+  setSchemas(schemas) {
+    if (this.disposed) {
+      return;
+    }
+    this.schemas.set(schemas);
+  }
+  /**
+   * 基于当前 root schemas 派生下一版 schemas。
+   */
+  updateSchemas(updater) {
+    if (this.disposed) {
+      return;
+    }
+    this.schemas.update(updater);
+  }
+  /**
+   * 更新表单默认配置。
+   *
+   * 合并传入属性到当前 defaultProps，然后重新编译根 schemas 并 reconcile。
+   * 字段级属性未设置时会回退到这些默认值。
+   */
+  updateDefaultProps(partial) {
+    if (this.disposed) {
+      return;
+    }
+    Object.assign(this.context.defaultProps, pick(partial, defaultConfigKey));
+    this.applySchemas(this.schemas.peek());
+  }
+  /**
+   * 将 schema source 的当前值提交到 runtime node。
+   */
+  applySchemas(schemas) {
+    if (this.disposed) {
+      return;
+    }
+    const previousRevision = this.viewRevision.revision.value;
+    const descriptors = compileToDescriptors([...schemas], this.context.defaultProps);
+    this.commitChildren(this.root, descriptors);
+    if (this.viewRevision.revision.value === previousRevision) {
+      this.viewRevision.bump();
+    }
+  }
+  /**
+   * 销毁表单实例
+   *
+   * 清除所有订阅回调和 effect，释放资源。通常在组件卸载时调用。
+   */
+  destroy() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    this.scope.dispose();
+    this.runtimeNodeManager.disposeTree(this.root);
+    this.scheduler.dispose();
+    this.store.destroy();
+  }
+  /**
+   * 获取当前 ViewSchemas。
+   */
+  getViewSchemas() {
+    return buildViewSchemas(this.root);
+  }
+  /**
+   * 订阅 ViewSchemas 变化。
+   */
+  subscribeViewSchemas(callback) {
+    return subscribeViewSchemas(this.root, this.viewRevision, callback);
+  }
+  /**
+   * 等待内部异步任务完成。
+   */
+  waitForIdle(timeout = 1e4) {
+    return this.scheduler.whenIdle(timeout);
+  }
+}
+function createForm(options = {}) {
+  return new CreateForm(options).getFormInstance();
+}
+function createField(form, name) {
+  const getValue = () => form.getFieldValue(name);
+  const setValue = (value) => {
+    form.setFieldValue(name, value);
+  };
+  const getInitialValue = () => {
+    return form.getInitialValue(name);
+  };
+  const setInitialValue = (value) => {
+    const result = {};
+    setByPath(result, name, value);
+    form.setInitialValues(result);
+  };
+  const getValues = () => form.getFieldsValue();
+  const getSnapshot = () => form.getFieldsSnapshot();
+  const validate = () => {
+    return form.validateField(name);
+  };
+  const getError = () => form.getFieldError(name);
+  const setError = (errors) => {
+    form.setFieldError(name, errors);
+  };
+  const clearError = () => {
+    form.setFieldError(name, []);
+  };
+  const registerRules = (rules, defaultMessage) => {
+    form.registerRules(name, rules, defaultMessage);
+  };
+  const unregisterRules = () => {
+    form.unregisterRules(name);
+  };
+  const isTouched = () => form.isFieldTouched(name) ?? false;
+  const reset = () => {
+    form.resetFields([name]);
+  };
+  const setPending = (pending, message) => {
+    form.setFieldPending(name, pending, message);
+  };
+  const isPending = () => form.isFieldPending(name) ?? false;
+  const effect = (fn) => {
+    return form.effect(fn);
+  };
+  return {
+    getValue,
+    setValue,
+    getInitialValue,
+    setInitialValue,
+    getValues,
+    getSnapshot,
+    validate,
+    getError,
+    setError,
+    clearError,
+    registerRules,
+    unregisterRules,
+    isTouched,
+    reset,
+    setPending,
+    isPending,
+    effect
+  };
+}
+function createEffect(callback) {
+  let cleanup;
+  let disposed = false;
+  const dispose = createSignalEffect(() => {
+    cleanup == null ? void 0 : cleanup();
+    cleanup = void 0;
+    const result = callback();
+    if (typeof result === "function") {
+      cleanup = result;
+    }
+  });
+  const api = () => {
+    if (disposed) return;
+    disposed = true;
+    dispose();
+    cleanup == null ? void 0 : cleanup();
+    cleanup = void 0;
+  };
+  return api;
+}
+const createWatchField = (form, name, callback, options) => {
+  let prev = form.getFieldSnapshot(name);
+  let isFirst = true;
+  const dispose = form.effect(() => {
+    const current = form.getFieldValue(name);
+    const latestSnapshot = form.getFieldsSnapshot();
+    if (isFirst) {
+      isFirst = false;
+      if (options.immediate) {
+        callback({ value: current, prevValue: void 0 }, latestSnapshot);
+      }
+      prev = current;
+      return;
+    }
+    if (options.inequality && isEqual(current, prev)) return;
+    callback({ value: current, prevValue: prev }, latestSnapshot);
+    prev = current;
+  });
+  return dispose;
+};
+const createWatchFields = (form, names, callback, options) => {
+  let prevValues = form.getFieldsSnapshot(names);
+  let isFirst = true;
+  const dispose = form.effect(() => {
+    const currentValues = form.getFieldsValue(names);
+    const latestSnapshot = form.getFieldsSnapshot();
+    if (isFirst) {
+      isFirst = false;
+      if (options.immediate) {
+        callback(
+          { changedPaths: names, changedValues: currentValues, prevValues: {} },
+          latestSnapshot
+        );
+      }
+      prevValues = { ...currentValues };
+      return;
+    }
+    if (options.inequality && isEqual(currentValues, prevValues)) return;
+    const changedValues = diff(currentValues, prevValues);
+    const changedPaths = collectObjectPathsByLeaf(changedValues);
+    callback({ changedPaths, changedValues, prevValues }, latestSnapshot);
+    prevValues = { ...currentValues };
+  });
+  return dispose;
+};
+const createWatchAll = (form, callback, options) => {
+  let isFirst = true;
+  let prevValues = form.getFieldsSnapshot();
+  const dispose = form.effect(() => {
+    const latestSnapshot = form.getFieldsSnapshot();
+    if (isFirst) {
+      isFirst = false;
+      if (options.immediate) {
+        callback(
+          {
+            changedPaths: [],
+            changedValues: latestSnapshot,
+            prevValues: {}
+          },
+          latestSnapshot
+        );
+      }
+      prevValues = { ...latestSnapshot };
+      return;
+    }
+    if (options.inequality && isEqual(latestSnapshot, prevValues)) return;
+    const changedValues = diff(latestSnapshot, prevValues);
+    const changedPaths = collectObjectPathsByLeaf(changedValues);
+    callback({ changedPaths, changedValues, prevValues }, latestSnapshot);
+    prevValues = { ...latestSnapshot };
+  });
+  return dispose;
+};
+function createWatch(form, nameOrNamesOrCallback, callbackOrOptions, maybeOptions) {
+  if (typeof nameOrNamesOrCallback === "function") {
+    return createWatchAll(
+      form,
+      nameOrNamesOrCallback,
+      callbackOrOptions || {}
+    );
+  }
+  if (typeof nameOrNamesOrCallback === "string" || typeof nameOrNamesOrCallback === "number") {
+    return createWatchField(
+      form,
+      nameOrNamesOrCallback,
+      callbackOrOptions,
+      maybeOptions || {}
+    );
+  }
+  return createWatchFields(
+    form,
+    nameOrNamesOrCallback,
+    callbackOrOptions,
+    maybeOptions || {}
+  );
+}
 const rendererRegistry = createRendererRegistry("input");
 const validatorRegistry = createValidatorsRegistry();
 const SCHEMX_INSTANCE_KEY = Symbol("SCHEMX_INSTANCE");
@@ -136,7 +4730,7 @@ const useDictionary = (options, fieldName) => {
       } catch (err) {
         lastError = normalizeError(err);
         if (attempt < maxRetries) {
-          await new Promise((r) => setTimeout(r, retryDelay));
+          await new Promise((r2) => setTimeout(r2, retryDelay));
         }
       }
     }
@@ -207,11 +4801,11 @@ function useContext() {
   }
   return context;
 }
-const isShallowEqual = (a, b) => {
-  const keysA = Object.keys(a);
-  const keysB = Object.keys(b);
+const isShallowEqual = (a2, b2) => {
+  const keysA = Object.keys(a2);
+  const keysB = Object.keys(b2);
   if (keysA.length !== keysB.length) return false;
-  return keysA.every((key) => a[key] === b[key]);
+  return keysA.every((key) => a2[key] === b2[key]);
 };
 function useStableRef(factory) {
   const stableRef = shallowRef({});
@@ -242,9 +4836,9 @@ function useFieldContext() {
   }
   return field;
 }
-function isValidTrigger(v) {
-  if (v === void 0) return false;
-  if (Array.isArray(v) && v.length === 0) return false;
+function isValidTrigger(v2) {
+  if (v2 === void 0) return false;
+  if (Array.isArray(v2) && v2.length === 0) return false;
   return true;
 }
 function mergeTrigger(columnTrigger, contextTrigger, defaultTrigger) {
@@ -252,7 +4846,7 @@ function mergeTrigger(columnTrigger, contextTrigger, defaultTrigger) {
   if (isValidTrigger(contextTrigger)) return contextTrigger;
   return defaultTrigger;
 }
-function normalizeTrigger(t) {
+function normalizeTrigger(t2) {
   const map = {
     onBlur: "blur",
     onChange: "change",
@@ -261,12 +4855,12 @@ function normalizeTrigger(t) {
     change: "change",
     submit: "submit"
   };
-  return map[t] ?? "submit";
+  return map[t2] ?? "submit";
 }
 function shouldValidateOn(event, trigger) {
   if (!trigger) return false;
   const triggers = Array.isArray(trigger) ? trigger : [trigger];
-  return triggers.some((t) => normalizeTrigger(t) === event);
+  return triggers.some((t2) => normalizeTrigger(t2) === event);
 }
 const isCamelCase = (str) => /[A-Z]/.test(str);
 const isKebabCase = (str) => str.includes("-");
@@ -327,9 +4921,9 @@ const FormGroup = /* @__PURE__ */ defineComponent((props, {
         "schemx-group__header--clickable": collapsible
       }),
       "onClick": toggle,
-      "onKeydown": (e) => {
-        if (e.key === "Enter" || e.key === " ") {
-          e.preventDefault();
+      "onKeydown": (e2) => {
+        if (e2.key === "Enter" || e2.key === " ") {
+          e2.preventDefault();
           toggle();
         }
       }
@@ -361,7 +4955,7 @@ const FormItem = /* @__PURE__ */ defineComponent((props, {
   const schemaRef = toRef(props, "schema");
   if (isViewGroupSchema(schemaRef.value)) {
     return () => {
-      return h(FormGroup, {
+      return h$1(FormGroup, {
         schema: schemaRef.value
       }, slots);
     };
@@ -378,10 +4972,10 @@ const FormItem = /* @__PURE__ */ defineComponent((props, {
     const hasRules = Array.isArray(rules) ? (rules == null ? void 0 : rules.length) > 0 : !!schema().rules;
     return isOperate && hasRules;
   });
-  const handleChange = (v) => {
+  const handleChange = (v2) => {
     var _a, _b;
-    field.setValue(v);
-    (_b = (_a = schema().componentProps) == null ? void 0 : _a.onChange) == null ? void 0 : _b.call(_a, v);
+    field.setValue(v2);
+    (_b = (_a = schema().componentProps) == null ? void 0 : _a.onChange) == null ? void 0 : _b.call(_a, v2);
     if (canVerified.value && shouldValidateOn("change", trigger.value)) {
       field.validate();
     }
@@ -414,7 +5008,7 @@ const FormItem = /* @__PURE__ */ defineComponent((props, {
     placeholder: schema().placeholder,
     onChange: handleChange,
     onBlur: handleBlur,
-    "onUpdate:value": (v) => field.setValue(v)
+    "onUpdate:value": (v2) => field.setValue(v2)
   }));
   const renderRequired = () => {
     if (!schema().required || schema().disabled || schema().readonly) {
@@ -448,7 +5042,7 @@ const FormItem = /* @__PURE__ */ defineComponent((props, {
       throw new Error(`[schemx] Can not find component renderer of "${schema().componentType}".`);
     }
     const childSlots = extractChildSlots(normalizeNameKey(schema().name), slots);
-    const columnElement = h(component, componentProps.value, childSlots);
+    const columnElement = h$1(component, componentProps.value, childSlots);
     const contentSlot = resolveSlot(slots, `${schema().name}Content`);
     if (contentSlot) {
       return contentSlot({
@@ -485,12 +5079,12 @@ const FormItem = /* @__PURE__ */ defineComponent((props, {
     }
     const labelPosition = schema().labelPosition || formContext.labelPosition;
     return createVNode("div", {
-      "class": classnames("schemx-item-wrapper", {
+      "class": classnames("schemx-item-wrapper")
+    }, [createVNode("div", {
+      "class": classnames("schemx-item", `schemx-item--label-${labelPosition}`, schema().class, {
         "is-readonly": schema().readonly,
         "is-disabled": schema().disabled
-      })
-    }, [createVNode("div", {
-      "class": classnames("schemx-item", `schemx-item--label-${labelPosition}`, schema().class),
+      }),
       "style": {
         ...schema().style ?? {}
       }
@@ -516,6 +5110,42 @@ const normalizeNameKey = (name) => {
   }
   return String(name);
 };
+function getSectionPosition(list, currentKey) {
+  const currentIndex = list.findIndex((item) => item.key === currentKey);
+  if (currentIndex === -1) {
+    return {
+      found: false,
+      isFirst: false,
+      isLast: false
+    };
+  }
+  const currentItem = list[currentIndex];
+  if (!isPositionItem(currentItem)) {
+    return {
+      found: true,
+      isFirst: false,
+      isLast: false
+    };
+  }
+  const prevItem = findPositionItem(list, currentIndex, -1);
+  const nextItem = findPositionItem(list, currentIndex, 1);
+  return {
+    found: true,
+    isFirst: !prevItem,
+    isLast: !nextItem
+  };
+}
+function isPositionItem(item) {
+  return !!item && item.componentType !== "group" && (!("visible" in item) || item.visible !== false);
+}
+function findPositionItem(list, startIndex, step) {
+  for (let index = startIndex + step; index >= 0 && index < list.length; index += step) {
+    if (isPositionItem(list[index])) {
+      return list[index];
+    }
+  }
+  return void 0;
+}
 const _sfc_main = /* @__PURE__ */ defineComponent({
   ...{ name: "SchemxForm" },
   __name: "form",
@@ -596,6 +5226,16 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       { deep: false, immediate: !!props.form }
     );
     const viewSchemas = useViewSchemas(form);
+    const getFormItemClass = (schema) => {
+      const { isFirst, isLast } = getSectionPosition(
+        viewSchemas.value,
+        schema.key
+      );
+      return {
+        "schemx-item-wrapper--first": isFirst,
+        "schemx-item-wrapper--last": isLast
+      };
+    };
     watchEffect(() => {
       form.updateDefaultProps(props);
     });
@@ -609,9 +5249,10 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         (openBlock(true), createElementBlock(Fragment, null, renderList(unref(viewSchemas), (schema) => {
           return openBlock(), createBlock(unref(FormItem), {
             key: schema.key,
-            schema
+            schema,
+            class: normalizeClass(getFormItemClass(schema))
           }, createSlots({ _: 2 }, [
-            renderList(_ctx.$slots, (_, slotName) => {
+            renderList(_ctx.$slots, (_2, slotName) => {
               return {
                 name: slotName,
                 fn: withCtx((slotProps) => [
@@ -619,7 +5260,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                 ])
               };
             })
-          ]), 1032, ["schema"]);
+          ]), 1032, ["schema", "class"]);
         }), 128))
       ], 2);
     };
@@ -660,7 +5301,7 @@ function WithRemoteOptions(WrappedComponent) {
           loading: props.dict ? dictResult == null ? void 0 : dictResult.loading.value : attrs.loading
         };
       });
-      return () => h(WrappedComponent, childrenProps.value, slots);
+      return () => h$1(WrappedComponent, childrenProps.value, slots);
     }
   });
 }
@@ -668,9 +5309,32 @@ export {
   FormGroup,
   FormItem,
   WithRemoteOptions,
+  collectObjectPathsByLeaf,
+  createEffect,
+  createField,
+  createForm,
+  createForm as createFormInstance,
+  createLifecycle,
+  createLifecycleBus,
+  createRendererRegistry,
+  createSchemas,
+  createValidator,
+  createValidatorsRegistry,
+  createWatch,
+  createWatchAll,
+  createWatchField,
+  createWatchFields,
   SchemxFormExport as default,
+  getByPath,
+  isBaseResolvedSchema,
+  isBaseSchema,
+  isDependencySchema,
+  isGroupResolvedSchema,
+  isGroupSchema,
+  isSchemxSchemas,
   rendererRegistry,
   SchemxFormExport as schemxForm,
+  setByPath,
   useContext,
   useDictionary,
   useEffect,