@reformer/core 2.0.0-beta.7 → 2.0.0-beta.8

package/dist/index.js

@@ -1,12 +1,14 @@
-import { d as y, w as u, E, r as j } from "./behaviors-DyPzh2-X.js";
-import { i as Se } from "./behaviors-DyPzh2-X.js";
-import { i as R, a as T, A as q, V as K, T as H } from "./validators-CWdzevnC.js";
-import { g as Ae, c as Ve, d as ke, v as xe, b as Pe } from "./validators-CWdzevnC.js";
-import { V as W, B as z, c as D } from "./registry-helpers--8-OogF8.js";
-import { R as Fe, a as Ce, e as Re, b as Te, g as De, t as Ne } from "./registry-helpers--8-OogF8.js";
-import { v4 as J } from "uuid";
-import L, { useRef as G, useCallback as b } from "react";
-class F {
+import { signal as g, computed as d, effect as m, batch as j } from "@preact/signals-core";
+import { F as S, E as V, V as K, B as H } from "./registry-helpers-Bv_BJ1s-.js";
+import { A as ke, R as xe, b as Fe, g as Te } from "./registry-helpers-Bv_BJ1s-.js";
+import { i as M, a as N, A as z, V as J, T as Y } from "./validators-BGsNOgT1.js";
+import { g as Pe, c as Ce, d as De, v as Re, b as Me } from "./validators-BGsNOgT1.js";
+import { c as I } from "./field-path-DuKdGcIE.js";
+import { a as Ie, e as Le, t as Be } from "./field-path-DuKdGcIE.js";
+import U, { useRef as P, useCallback as b, useSyncExternalStore as Q } from "react";
+import { i as $e } from "./index-D25LsbRm.js";
+import { r as We, s as qe, a as je } from "./safe-effect-Dh8uw81c.js";
+class C {
   // ============================================================================
   // Protected состояние (для Template Method паттерна)
   // ============================================================================
@@ -14,17 +16,17 @@ class F {
    * Пользователь взаимодействовал с узлом (touched)
    * Protected: наследники могут читать/изменять через методы
    */
-  _touched = y(!1);
+  _touched = g(!1);
   /**
    * Значение узла было изменено (dirty)
    * Protected: наследники могут читать/изменять через методы
    */
-  _dirty = y(!1);
+  _dirty = g(!1);
   /**
    * Текущий статус узла
    * Protected: наследники могут читать/изменять через методы
    */
-  _status = y("valid");
+  _status = g("valid");
   // ============================================================================
   // Публичные computed signals (readonly для внешнего мира)
   // ============================================================================
@@ -32,33 +34,33 @@ class F {
    * Пользователь взаимодействовал с узлом (touched)
    * Computed из _touched для предоставления readonly интерфейса
    */
-  touched = u(() => this._touched.value);
+  touched = d(() => this._touched.value);
   /**
    * Пользователь не взаимодействовал с узлом (untouched)
    */
-  untouched = u(() => !this._touched.value);
+  untouched = d(() => !this._touched.value);
   /**
    * Значение узла было изменено (dirty)
    * Computed из _dirty для предоставления readonly интерфейса
    */
-  dirty = u(() => this._dirty.value);
+  dirty = d(() => this._dirty.value);
   /**
    * Значение узла не было изменено (pristine)
    */
-  pristine = u(() => !this._dirty.value);
+  pristine = d(() => !this._dirty.value);
   /**
    * Текущий статус узла
    * Computed из _status для предоставления readonly интерфейса
    */
-  status = u(() => this._status.value);
+  status = d(() => this._status.value);
   /**
    * Узел отключен (disabled)
    */
-  disabled = u(() => this._status.value === "disabled");
+  disabled = d(() => this._status.value === "disabled");
   /**
    * Узел включен (enabled)
    */
-  enabled = u(() => this._status.value !== "disabled");
+  enabled = d(() => this._status.value !== "disabled");
   /**
    * Получить ошибки валидации с фильтрацией
    *
@@ -100,17 +102,17 @@ class F {
    */
   getErrors(e) {
     const t = this.errors.value;
-    return e ? t.filter((r) => {
-      if (e.code !== void 0 && !(Array.isArray(e.code) ? e.code : [e.code]).includes(r.code) || e.message !== void 0 && !r.message.toLowerCase().includes(e.message.toLowerCase()))
+    return e ? t.filter((s) => {
+      if (e.code !== void 0 && !(Array.isArray(e.code) ? e.code : [e.code]).includes(s.code) || e.message !== void 0 && !s.message.toLowerCase().includes(e.message.toLowerCase()))
         return !1;
       if (e.params !== void 0) {
-        if (!r.params)
+        if (!s.params)
           return !1;
-        for (const [i, a] of Object.entries(e.params))
-          if (r.params[i] !== a)
+        for (const [i, r] of Object.entries(e.params))
+          if (s.params[i] !== r)
             return !1;
       }
-      return !(e.predicate !== void 0 && !e.predicate(r));
+      return !(e.predicate !== void 0 && !e.predicate(s));
     }) : t;
   }
   // ============================================================================
@@ -283,7 +285,7 @@ class F {
   onEnable() {
   }
 }
-class C {
+class D {
   /**
    * Хранилище подписок
    * Ключ: уникальный идентификатор подписки
@@ -451,161 +453,196 @@ class C {
     this.clear();
   }
 }
-let Y = 0;
-function S(s) {
-  return `${s}-${++Y}`;
+const w = {
+  /** FieldNode.watch() */
+  Watch: "watch",
+  /** FieldNode.computeFrom() */
+  ComputeFrom: "computeFrom",
+  /** GroupNode.linkFields() */
+  LinkFields: "linkFields",
+  /** GroupNode.watchField() */
+  WatchField: "watchField",
+  /** ArrayNode.watchItems() */
+  WatchItems: "watchItems",
+  /** ArrayNode.watchLength() */
+  WatchLength: "watchLength"
+};
+let X = 0;
+function A(a) {
+  return `${a}-${++X}`;
 }
-var V = /* @__PURE__ */ ((s) => (s.THROW = "throw", s.LOG = "log", s.CONVERT = "convert", s))(V || {});
-class O {
+class Z {
+  /** Внутренний сигнал статуса */
+  _status;
+  /** Публичный read-only сигнал статуса */
+  status;
+  /** Поле валидно */
+  valid;
+  /** Поле невалидно */
+  invalid;
+  /** Идет валидация */
+  pending;
+  /** Поле отключено */
+  disabled;
   /**
-   * Обработать ошибку согласно заданной стратегии
+   * @param initial - Начальный статус (по умолчанию 'valid')
+   */
+  constructor(e = "valid") {
+    this._status = g(e), this.status = d(() => this._status.value), this.valid = d(() => this._status.value === "valid"), this.invalid = d(() => this._status.value === "invalid"), this.pending = d(() => this._status.value === "pending"), this.disabled = d(() => this._status.value === "disabled");
+  }
+  /**
+   * Начать валидацию
    *
-   * @param error Ошибка для обработки (Error | string | unknown)
-   * @param context Контекст ошибки для логирования (например, 'AsyncValidator', 'BehaviorRegistry')
-   * @param strategy Стратегия обработки (THROW | LOG | CONVERT)
-   * @returns ValidationError если strategy = CONVERT, undefined если strategy = LOG, никогда не возвращается если strategy = THROW
+   * Переводит статус в 'pending' если поле не отключено
    *
    * @example
    * ```typescript
-   * // THROW - пробросить ошибку
-   * try {
-   *   riskyOperation();
-   * } catch (error) {
-   *   FormErrorHandler.handle(error, 'RiskyOperation', ErrorStrategy.THROW);
-   *   // Этот код никогда не выполнится
-   * }
+   * statusMachine.startValidation();
+   * // status: 'pending'
+   * ```
+   */
+  startValidation() {
+    this._status.value !== "disabled" && (this._status.value = "pending");
+  }
+  /**
+   * Завершить валидацию
    *
-   * // LOG - залогировать и продолжить
-   * try {
-   *   nonCriticalOperation();
-   * } catch (error) {
-   *   FormErrorHandler.handle(error, 'NonCritical', ErrorStrategy.LOG);
-   *   // Продолжаем выполнение
-   * }
+   * @param hasErrors - Есть ли ошибки валидации
    *
-   * // CONVERT - конвертировать в ValidationError
-   * try {
-   *   await validator(value);
-   * } catch (error) {
-   *   const validationError = FormErrorHandler.handle(
-   *     error,
-   *     'AsyncValidator',
-   *     ErrorStrategy.CONVERT
-   *   );
-   *   return validationError;
-   * }
+   * @example
+   * ```typescript
+   * // Валидация успешна
+   * statusMachine.completeValidation(false);
+   * // status: 'valid'
+   *
+   * // Есть ошибки
+   * statusMachine.completeValidation(true);
+   * // status: 'invalid'
    * ```
    */
-  static handle(e, t, r = "throw") {
-    const i = this.extractMessage(e);
-    switch (r) {
-      case "throw":
-        throw e;
-      case "log":
-        return;
-      case "convert":
-        return {
-          code: "validator_error",
-          message: i,
-          params: { field: t }
-        };
-    }
+  completeValidation(e) {
+    (this._status.value === "pending" || this._status.value !== "disabled") && (this._status.value = e ? "invalid" : "valid");
   }
   /**
-   * Извлечь сообщение из ошибки
+   * Установить ошибки напрямую (без перехода через pending)
    *
-   * Обрабатывает различные типы ошибок:
-   * - Error объекты → error.message
-   * - Строки → возвращает как есть
-   * - Объекты с message → извлекает message
-   * - Другое → String(error)
+   * Используется для синхронной валидации или установки ошибок извне
    *
-   * @param error Ошибка для извлечения сообщения
-   * @returns Сообщение ошибки
-   * @private
+   * @param hasErrors - Есть ли ошибки
    *
    * @example
    * ```typescript
-   * FormErrorHandler.extractMessage(new Error('Test'));
-   * // 'Test'
-   *
-   * FormErrorHandler.extractMessage('String error');
-   * // 'String error'
+   * statusMachine.setErrors(true);
+   * // status: 'invalid'
+   * ```
+   */
+  setErrors(e) {
+    this._status.value !== "disabled" && (this._status.value = e ? "invalid" : "valid");
+  }
+  /**
+   * Отключить поле
    *
-   * FormErrorHandler.extractMessage({ message: 'Object error' });
-   * // 'Object error'
+   * Переводит статус в 'disabled'
    *
-   * FormErrorHandler.extractMessage(null);
-   * // 'null'
+   * @example
+   * ```typescript
+   * statusMachine.disable();
+   * // status: 'disabled'
    * ```
    */
-  static extractMessage(e) {
-    return e instanceof Error ? e.message : typeof e == "string" ? e : typeof e == "object" && e !== null && "message" in e ? String(e.message) : String(e);
+  disable() {
+    this._status.value = "disabled";
   }
   /**
-   * Создать ValidationError с заданными параметрами
+   * Включить поле
    *
-   * Утилитная функция для создания ValidationError объектов
-   *
-   * @param code Код ошибки
-   * @param message Сообщение ошибки
-   * @param field Поле (опционально)
-   * @returns ValidationError объект
+   * @param hasErrors - Есть ли ошибки (определяет valid/invalid)
    *
    * @example
    * ```typescript
-   * const error = FormErrorHandler.createValidationError(
-   *   'required',
-   *   'This field is required',
-   *   'email'
-   * );
-   * // { code: 'required', message: 'This field is required', field: 'email' }
+   * statusMachine.enable(false);
+   * // status: 'valid'
+   *
+   * statusMachine.enable(true);
+   * // status: 'invalid'
    * ```
    */
-  static createValidationError(e, t, r) {
-    return {
-      code: e,
-      message: t,
-      params: r ? { field: r } : void 0
-    };
+  enable(e = !1) {
+    this._status.value = e ? "invalid" : "valid";
   }
   /**
-   * Проверить, является ли объект ValidationError
-   *
-   * Type guard для ValidationError
+   * Обработать событие (альтернативный API)
    *
-   * @param value Значение для проверки
-   * @returns true если value является ValidationError
+   * @param event - Событие для обработки
    *
    * @example
    * ```typescript
-   * if (FormErrorHandler.isValidationError(result)) {
-   *   console.log(result.code); // OK, типобезопасно
-   * }
+   * statusMachine.dispatch({ type: 'START_VALIDATION' });
+   * statusMachine.dispatch({ type: 'VALIDATION_FAILURE' });
    * ```
    */
-  static isValidationError(e) {
-    return typeof e == "object" && e !== null && "code" in e && "message" in e && typeof e.code == "string" && typeof e.message == "string";
+  dispatch(e) {
+    switch (e.type) {
+      case "START_VALIDATION":
+        this.startValidation();
+        break;
+      case "VALIDATION_SUCCESS":
+        this.completeValidation(!1);
+        break;
+      case "VALIDATION_FAILURE":
+        this.completeValidation(!0);
+        break;
+      case "DISABLE":
+        this.disable();
+        break;
+      case "ENABLE":
+        this.enable(e.hasErrors);
+        break;
+      case "SET_ERRORS":
+        this.setErrors(e.hasErrors);
+        break;
+    }
+  }
+  /**
+   * Получить текущий статус
+   */
+  getStatus() {
+    return this._status.value;
+  }
+  /**
+   * Проверить, можно ли начать валидацию
+   */
+  canValidate() {
+    return this._status.value !== "disabled";
   }
 }
-class Q extends F {
+class ee extends C {
   // ============================================================================
   // Приватные сигналы
   // ============================================================================
   _value;
   _errors;
-  // _touched, _dirty, _status наследуются от FormNode (protected)
-  _pending;
+  // _touched, _dirty наследуются от FormNode (protected)
+  // _status управляется через statusMachine
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   _componentProps;
+  /**
+   * State machine для управления статусом поля
+   * Централизует логику переходов между valid/invalid/pending/disabled
+   */
+  statusMachine;
   // ============================================================================
   // Публичные computed signals
   // ============================================================================
   value;
+  // valid, invalid, pending, status, disabled берутся из statusMachine
   valid;
   invalid;
-  // touched, dirty, status наследуются от FormNode
   pending;
+  // Override status и disabled из базового класса
+  status;
+  disabled;
+  // touched, dirty наследуются от FormNode
   errors;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   componentProps;
@@ -621,23 +658,26 @@ class Q extends F {
   asyncValidators;
   updateOn;
   initialValue;
-  currentValidationId = 0;
   currentAbortController;
   debounceMs;
   validateDebounceTimer;
-  validateDebounceResolve;
+  /**
+   * Pending debounced validation state
+   * Contains resolve function and AbortController for cancellation
+   */
+  pendingValidation;
   /**
    * Менеджер подписок для централизованного cleanup
    * Использует SubscriptionManager вместо массива для управления подписками
    */
-  disposers = new C();
+  disposers = new D();
   component;
   // ============================================================================
   // Конструктор
   // ============================================================================
   constructor(e) {
-    super(), this.initialValue = e.value, this.validators = e.validators || [], this.asyncValidators = e.asyncValidators || [], this.updateOn = e.updateOn || "blur", this.debounceMs = e.debounce || 0, this.component = e.component, this._value = y(e.value), this._errors = y([]), this._pending = y(!1), this._componentProps = y(e.componentProps || {}), e.disabled && (this._status.value = "disabled"), this.value = u(() => this._value.value), this.valid = u(() => this._status.value === "valid"), this.invalid = u(() => this._status.value === "invalid"), this.pending = u(() => this._pending.value), this.errors = u(() => this._errors.value), this.componentProps = u(() => this._componentProps.value), this.shouldShowError = u(
-      () => this._status.value === "invalid" && (this._touched.value || this._dirty.value)
+    super(), this.initialValue = e.value, this.validators = e.validators || [], this.asyncValidators = e.asyncValidators || [], this.updateOn = e.updateOn || "blur", this.debounceMs = e.debounce || 0, this.component = e.component, this._value = g(e.value), this._errors = g([]), this._componentProps = g(e.componentProps || {}), this.statusMachine = new Z(e.disabled ? "disabled" : "valid"), this.value = d(() => this._value.value), this.valid = d(() => this.statusMachine.valid.value), this.invalid = d(() => this.statusMachine.invalid.value), this.pending = d(() => this.statusMachine.pending.value), this.status = d(() => this.statusMachine.status.value), this.disabled = d(() => this.statusMachine.disabled.value), this.errors = d(() => this._errors.value), this.componentProps = d(() => this._componentProps.value), this.shouldShowError = d(
+      () => this.statusMachine.invalid.value && (this._touched.value || this._dirty.value)
     );
   }
   // ============================================================================
@@ -649,12 +689,12 @@ class Q extends F {
   setValue(e, t) {
     if (this._value.value = e, this._dirty.value = !0, t?.emitEvent === !1)
       return;
-    const r = this.validators.length > 0 || this.asyncValidators.length > 0, i = this._errors.value.length > 0;
+    const s = this.validators.length > 0 || this.asyncValidators.length > 0, i = this._errors.value.length > 0;
     if (this.updateOn === "change") {
       this.validate();
       return;
     }
-    i && r && this.validate();
+    i && s && this.validate();
   }
   patchValue(e) {
     this.setValue(e);
@@ -683,7 +723,7 @@ class Q extends F {
    * ```
    */
   reset(e) {
-    this._value.value = e !== void 0 ? e : this.initialValue, this._errors.value = [], this._touched.value = !1, this._dirty.value = !1, this._status.value = "valid";
+    this._value.value = e !== void 0 ? e : this.initialValue, this._errors.value = [], this._touched.value = !1, this._dirty.value = !1, this.statusMachine.setErrors(!1);
   }
   /**
    * Сбросить поле к исходному значению (initialValue)
@@ -713,13 +753,25 @@ class Q extends F {
   resetToInitial() {
     this.reset(this.initialValue);
   }
+  /**
+   * Cancel any pending validation (debounced or running)
+   * @private
+   * @remarks
+   * Centralizes all cancellation logic:
+   * - Aborts pending debounced validation and resolves its promise
+   * - Clears debounce timer
+   * - Aborts currently running async validation
+   */
+  cancelPendingValidation() {
+    this.pendingValidation && (this.pendingValidation.abortController.abort(), this.pendingValidation.resolve(!1), this.pendingValidation = void 0), this.validateDebounceTimer && (clearTimeout(this.validateDebounceTimer), this.validateDebounceTimer = void 0), this.currentAbortController && (this.currentAbortController.abort(), this.currentAbortController = void 0);
+  }
   /**
    * Запустить валидацию поля
    * @param options - опции валидации
    * @returns `Promise<boolean>` - true если поле валидно
    *
    * @remarks
-   * Метод защищен от race conditions через validationId.
+   * Метод защищен от race conditions через AbortController.
    * При быстром вводе только последняя валидация применяет результаты.
    *
    * @example
@@ -733,86 +785,102 @@ class Q extends F {
    */
   async validate(e) {
     const t = e?.debounce ?? this.debounceMs;
-    return t > 0 && this.asyncValidators.length > 0 ? new Promise((r) => {
-      const i = this.currentValidationId;
-      this.validateDebounceResolve && this.validateDebounceResolve(!1), this.validateDebounceTimer && clearTimeout(this.validateDebounceTimer), this.validateDebounceResolve = r, this.validateDebounceTimer = setTimeout(async () => {
-        if (this.validateDebounceResolve = void 0, i !== this.currentValidationId) {
-          r(!1);
+    if (this.cancelPendingValidation(), t <= 0 || this.asyncValidators.length === 0)
+      return this.validateImmediate();
+    const s = new AbortController();
+    return new Promise((i) => {
+      this.pendingValidation = { resolve: i, abortController: s }, this.validateDebounceTimer = setTimeout(async () => {
+        if (this.validateDebounceTimer = void 0, s.signal.aborted) {
+          i(!1);
           return;
         }
-        const a = await this.validateImmediate();
-        r(a);
-      }, t);
-    }) : this.validateImmediate();
+        this.pendingValidation = void 0;
+        const r = await this.validateImmediate(s);
+        i(r);
+      }, t), s.signal.addEventListener(
+        "abort",
+        () => {
+          this.validateDebounceTimer && (clearTimeout(this.validateDebounceTimer), this.validateDebounceTimer = void 0), i(!1);
+        },
+        { once: !0 }
+      );
+    });
   }
   /**
    * Немедленная валидация без debounce
    * @private
+   * @param providedController - AbortController from debounced validate()
    * @remarks
    * Защищена от race conditions через AbortController:
-   * - Отменяет предыдущую валидацию при запуске новой
+   * - Отменяет предыдущую валидацию при запуске новой (if no controller provided)
    * - Передаёт AbortSignal в async валидаторы для отмены операций (например, fetch)
    * - Проверяет signal.aborted в ключевых точках
    */
-  async validateImmediate() {
-    this.currentAbortController?.abort();
-    const e = new AbortController();
-    this.currentAbortController = e;
-    const { signal: t } = e;
-    ++this.currentValidationId;
-    const r = [];
-    for (const a of this.validators) {
-      const n = a(this._value.value);
-      n && r.push(n);
+  async validateImmediate(e) {
+    const t = e ?? new AbortController();
+    e || this.currentAbortController?.abort(), this.currentAbortController = t;
+    const { signal: s } = t, i = [];
+    for (const n of this.validators) {
+      const o = n(this._value.value);
+      o && i.push(o);
     }
-    if (t.aborted)
+    if (s.aborted)
       return !1;
-    if (r.length > 0)
-      return this._errors.value = r, this._status.value = "invalid", !1;
+    if (i.length > 0) {
+      this._errors.value = i;
+      const n = i.some((o) => o.severity !== "warning");
+      if (this.statusMachine.setErrors(n), n)
+        return !1;
+    }
     if (this.asyncValidators.length > 0) {
-      if (t.aborted)
+      if (s.aborted)
         return !1;
-      this._pending.value = !0, this._status.value = "pending";
+      this.statusMachine.startValidation();
       try {
-        const a = await Promise.all(
-          this.asyncValidators.map(async (o) => {
-            if (t.aborted)
+        const n = await Promise.all(
+          this.asyncValidators.map(async (l) => {
+            if (s.aborted)
               throw new DOMException("Validation aborted", "AbortError");
             try {
-              const l = await o(this._value.value, { signal: t });
-              if (t.aborted)
+              const u = await l(this._value.value, { signal: s });
+              if (s.aborted)
                 throw new DOMException("Validation aborted", "AbortError");
-              return l;
-            } catch (l) {
-              if (l instanceof DOMException && l.name === "AbortError")
-                throw l;
-              return O.handle(
-                l,
+              return u;
+            } catch (u) {
+              if (u instanceof DOMException && u.name === "AbortError")
+                throw u;
+              return S.handle(
+                u,
                 "FieldNode AsyncValidator",
                 V.CONVERT
               );
             }
           })
         );
-        if (t.aborted)
+        if (s.aborted)
           return !1;
-        this._pending.value = !1;
-        const n = a.filter(Boolean);
-        if (n.length > 0)
-          return this._errors.value = n, this._status.value = "invalid", !1;
-      } catch (a) {
-        if (a instanceof DOMException && a.name === "AbortError")
+        const o = n.filter(Boolean);
+        if (o.length > 0) {
+          this._errors.value = o;
+          const l = o.some((u) => u.severity !== "warning");
+          if (this.statusMachine.completeValidation(l), l)
+            return !1;
+        }
+      } catch (n) {
+        if (n instanceof DOMException && n.name === "AbortError")
           return !1;
-        throw a;
+        throw n;
       }
     }
-    return t.aborted ? !1 : ((this.validators.length > 0 || this.asyncValidators.length > 0) && (this._errors.value = [], this._status.value = "valid"), this._errors.value.length === 0);
+    return s.aborted ? !1 : ((this.validators.length > 0 || this.asyncValidators.length > 0) && (this._errors.value = [], this.statusMachine.completeValidation(!1)), !this._errors.value.some((n) => n.severity !== "warning"));
   }
   setErrors(e) {
-    this._errors.value = e, this._status.value = e.length > 0 ? "invalid" : "valid";
+    this._errors.value = e;
+    const t = e.some((s) => s.severity !== "warning");
+    this.statusMachine.setErrors(t);
   }
   clearErrors() {
-    this._errors.value = [], this._status.value = "valid";
+    this._errors.value = [], this.statusMachine.setErrors(!1);
   }
   // ============================================================================
   // Protected hooks (Template Method pattern)
@@ -828,18 +896,18 @@ class Q extends F {
   /**
    * Hook: вызывается после disable()
    *
-   * Для FieldNode: очищаем ошибки валидации
+   * Для FieldNode: синхронизируем statusMachine и очищаем ошибки
    */
   onDisable() {
-    this._errors.value = [];
+    this.statusMachine.disable(), this._errors.value = [];
   }
   /**
    * Hook: вызывается после enable()
    *
-   * Для FieldNode: запускаем валидацию
+   * Для FieldNode: синхронизируем statusMachine и запускаем валидацию
    */
   onEnable() {
-    this.validate();
+    this.statusMachine.enable(this._errors.value.length > 0), this.validate();
   }
   /**
    * Обновляет свойства компонента (например, опции для Select)
@@ -904,25 +972,35 @@ class Q extends F {
    * Подписка на изменения значения поля
    * Автоматически отслеживает изменения через @preact/signals effect
    *
-   * @param callback - Функция, вызываемая при изменении значения
+   * @param callback - Функция, вызываемая при изменении значения.
+   *   Для async операций передается AbortSignal во втором параметре.
    * @returns Функция отписки для cleanup
    *
    * @example
    * ```typescript
+   * // Синхронный callback
    * const unsubscribe = form.email.watch((value) => {
    *   console.log('Email changed:', value);
    * });
    *
+   * // Асинхронный callback с поддержкой отмены
+   * const unsubscribe = form.email.watch(async (value, signal) => {
+   *   const result = await fetch('/api/validate', { signal });
+   *   // ...
+   * });
+   *
    * // Cleanup
    * useEffect(() => unsubscribe, []);
    * ```
    */
   watch(e) {
-    const t = E(() => {
-      const i = this.value.value;
-      e(i);
-    }), r = S("watch");
-    return this.disposers.add(r, t);
+    const t = new AbortController(), s = m(() => {
+      const r = this.value.value;
+      e(r, t.signal);
+    }), i = A(w.Watch);
+    return this.disposers.add(i, () => {
+      t.abort(), s();
+    });
   }
   /**
    * Вычисляемое значение из других полей
@@ -947,11 +1025,11 @@ class Q extends F {
    * ```
    */
   computeFrom(e, t) {
-    const r = E(() => {
-      const a = e.map((o) => o.value), n = t(...a);
+    const s = m(() => {
+      const r = e.map((o) => o.value), n = t(...r);
       this.setValue(n, { emitEvent: !1 });
-    }), i = S("computeFrom");
-    return this.disposers.add(i, r);
+    }), i = A(w.ComputeFrom);
+    return this.disposers.add(i, s);
   }
   /**
    * Очистить все ресурсы и таймеры
@@ -960,9 +1038,9 @@ class Q extends F {
    * @remarks
    * Освобождает все ресурсы:
    * - Отписывает все subscriptions через SubscriptionManager
-   * - Очищает debounce таймер
-   * - Resolve'ит висячий debounce промис (предотвращает утечку памяти)
-   * - Отменяет текущую async валидацию через AbortController
+   * - Отменяет pending/running валидации через cancelPendingValidation()
+   *
+   * Использует try-finally для гарантированного cleanup даже при ошибках.
    *
    * @example
    * ```typescript
@@ -974,10 +1052,14 @@ class Q extends F {
    * ```
    */
   dispose() {
-    this.disposers.dispose(), this.validateDebounceTimer && (clearTimeout(this.validateDebounceTimer), this.validateDebounceTimer = void 0), this.validateDebounceResolve && (this.validateDebounceResolve(!1), this.validateDebounceResolve = void 0), this.currentAbortController && (this.currentAbortController.abort(), this.currentAbortController = void 0);
+    try {
+      this.disposers.dispose();
+    } finally {
+      this.cancelPendingValidation();
+    }
   }
 }
-class X {
+class te {
   form;
   constructor(e) {
     this.form = e;
@@ -993,8 +1075,8 @@ class X {
    * @param validators Зарегистрированные валидаторы
    */
   async apply(e) {
-    const { validatorsByField: t, treeValidators: r } = this.groupValidators(e);
-    await this.applyFieldValidators(t), this.applyTreeValidators(r);
+    const { validatorsByField: t, treeValidators: s } = this.groupValidators(e);
+    await this.applyFieldValidators(t), this.applyTreeValidators(s);
   }
   /**
    * Группировка валидаторов по типам
@@ -1007,15 +1089,15 @@ class X {
    * @returns Сгруппированные валидаторы
    */
   groupValidators(e) {
-    const t = /* @__PURE__ */ new Map(), r = [];
+    const t = /* @__PURE__ */ new Map(), s = [];
     for (const i of e)
       if (i.type === "tree")
-        r.push(i);
+        s.push(i);
       else {
-        const a = t.get(i.fieldPath) || [];
-        a.push(i), t.set(i.fieldPath, a);
+        const r = t.get(i.fieldPath) || [];
+        r.push(i), t.set(i.fieldPath, r);
       }
-    return { validatorsByField: t, treeValidators: r };
+    return { validatorsByField: t, treeValidators: s };
   }
   /**
    * Применение field валидаторов к полям
@@ -1029,44 +1111,44 @@ class X {
    * @param validatorsByField Валидаторы, сгруппированные по полям
    */
   async applyFieldValidators(e) {
-    for (const [t, r] of e) {
+    for (const [t, s] of e) {
       const i = this.form.getFieldByPath(t);
       if (!i) {
         console.warn(`Field ${t} not found in GroupNode`);
         continue;
       }
-      if (!R(i) && !T(i)) {
+      if (!M(i) && !N(i)) {
         process.env.NODE_ENV !== "production" && console.warn(`Validation can only run on FieldNode or ArrayNode, skipping ${t}`);
         continue;
       }
-      const a = [];
+      const r = [];
       let n;
-      if (T(i)) {
+      if (N(i)) {
         const o = i.getValue();
-        n = new q(this.form, t, o);
+        n = new z(this.form, t, o);
       } else
-        n = new K(this.form, t, i);
-      for (const o of r)
+        n = new J(this.form, t, i);
+      for (const o of s)
         if (!(o.condition && !this.checkCondition(o.condition)))
           try {
             let l = null;
-            const h = n.value();
+            const u = n.value();
             if (o.type === "sync") {
-              const m = o.validator;
-              l = m(h, n);
+              const v = o.validator;
+              l = v(u, n);
             } else if (o.type === "async") {
-              const m = o.validator;
-              l = await m(h, n);
+              const v = o.validator;
+              l = await v(u, n);
             }
-            l && a.push(l);
+            l && r.push(l);
           } catch (l) {
-            O.handle(
+            S.handle(
               l,
               `ValidationApplicator: validator for ${t}`,
               V.LOG
             );
           }
-      a.length > 0 ? i.setErrors(a) : i.clearErrors();
+      r.length > 0 ? i.setErrors(r) : i.clearErrors();
     }
   }
   /**
@@ -1079,24 +1161,24 @@ class X {
    */
   applyTreeValidators(e) {
     for (const t of e) {
-      const r = new H(this.form);
+      const s = new Y(this.form);
       if (!(t.condition && !this.checkCondition(t.condition)))
         try {
           if (t.type !== "tree")
             continue;
-          const i = t.validator, a = i(r);
-          if (a && t.options && "targetField" in t.options) {
+          const i = t.validator, r = i(s);
+          if (r && t.options && "targetField" in t.options) {
             const n = t.options.targetField;
             if (n) {
               const o = this.form.getFieldByPath(String(n));
-              if (o && R(o)) {
+              if (o && M(o)) {
                 const l = o.errors.value;
-                o.setErrors([...l, a]);
+                o.setErrors([...l, r]);
               }
             }
           }
         } catch (i) {
-          O.handle(i, "ValidationApplicator: tree validator", V.LOG);
+          S.handle(i, "ValidationApplicator: tree validator", V.LOG);
         }
     }
   }
@@ -1113,11 +1195,11 @@ class X {
     const t = this.form.getFieldByPath(e.fieldPath);
     if (!t)
       return !1;
-    const r = t.value.value;
-    return e.conditionFn(r);
+    const s = t.value.value;
+    return e.conditionFn(s);
   }
 }
-class Z {
+class se {
   /**
    * Парсит путь в массив сегментов
    *
@@ -1144,22 +1226,22 @@ class Z {
    */
   parsePath(e) {
     const t = [];
-    let r = "", i = !1;
-    for (let a = 0; a < e.length; a++) {
-      const n = e[a];
-      n === "[" ? (i = !0, r += n) : n === "]" ? (i = !1, r += n) : n === "." && !i ? r && (this.addSegment(t, r), r = "") : r += n;
+    let s = "", i = !1;
+    for (let r = 0; r < e.length; r++) {
+      const n = e[r];
+      n === "[" ? (i = !0, s += n) : n === "]" ? (i = !1, s += n) : n === "." && !i ? s && (this.addSegment(t, s), s = "") : s += n;
     }
-    return r && this.addSegment(t, r), t;
+    return s && this.addSegment(t, s), t;
   }
   /**
    * Добавляет сегмент в массив, обрабатывая массивы
    * @private
    */
   addSegment(e, t) {
-    const r = t.match(/^(.+)\[(\d+)\]$/);
-    r ? e.push({
-      key: r[1],
-      index: parseInt(r[2], 10)
+    const s = t.match(/^(.+)\[(\d+)\]$/);
+    s ? e.push({
+      key: s[1],
+      index: parseInt(s[2], 10)
     }) : e.push({ key: t });
   }
   /**
@@ -1194,13 +1276,13 @@ class Z {
    * ```
    */
   getValueByPath(e, t) {
-    const r = this.parsePath(t);
+    const s = this.parsePath(t);
     let i = e;
-    for (const a of r) {
+    for (const r of s) {
       if (i == null) return;
-      if (i = i[a.key], a.index !== void 0) {
+      if (i = i[r.key], r.index !== void 0) {
         if (!Array.isArray(i)) return;
-        i = i[a.index];
+        i = i[r.index];
       }
     }
     return i;
@@ -1232,31 +1314,31 @@ class Z {
    * // obj3.items[0].title === 'New'
    * ```
    */
-  setValueByPath(e, t, r) {
+  setValueByPath(e, t, s) {
     const i = this.parsePath(t);
     if (i.length === 0)
       throw new Error("Cannot set value: empty path");
-    let a = e;
+    let r = e;
     for (let o = 0; o < i.length - 1; o++) {
       const l = i[o];
-      let h = a[l.key];
+      let u = r[l.key];
       if (l.index !== void 0) {
-        if (!Array.isArray(h))
-          throw new Error(`Expected array at path segment: ${l.key}, but got ${typeof h}`);
-        a = h[l.index];
+        if (!Array.isArray(u))
+          throw new Error(`Expected array at path segment: ${l.key}, but got ${typeof u}`);
+        r = u[l.index];
       } else
-        h == null && (a[l.key] = {}, h = a[l.key]), a = h;
+        u == null && (r[l.key] = {}, u = r[l.key]), r = u;
     }
     const n = i[i.length - 1];
     if (n.index !== void 0) {
-      const o = a[n.key];
+      const o = r[n.key];
       if (!Array.isArray(o))
         throw new Error(
           `Expected array at path segment: ${n.key}, but got ${typeof o}`
         );
-      o[n.index] = r;
+      o[n.index] = s;
     } else
-      a[n.key] = r;
+      r[n.key] = s;
   }
   /**
    * Получить значение из FormNode по пути
@@ -1293,9 +1375,9 @@ class Z {
    * ```
    */
   getFormNodeValue(e, t) {
-    const r = this.getNodeByPath(e, t);
-    if (r != null)
-      return this.isFormNode(r) ? r.value.value : r;
+    const s = this.getNodeByPath(e, t);
+    if (s != null)
+      return this.isFormNode(s) ? s.value.value : s;
   }
   /**
    * Type guard для проверки, является ли объект FormNode
@@ -1353,40 +1435,177 @@ class Z {
    * ```
    */
   getNodeByPath(e, t) {
-    const r = this.parsePath(t);
+    const s = this.parsePath(t);
     let i = e;
-    for (const a of r) {
+    for (const r of s) {
       if (i == null) return null;
       const n = i;
       if (n.fields && n.fields instanceof Map) {
-        if (i = n.fields.get(a.key), a.index === void 0) {
+        if (i = n.fields.get(r.key), r.index === void 0) {
           if (i == null) return null;
           continue;
         }
-      } else if (a.index !== void 0 && n.items) {
+      } else if (r.index !== void 0 && n.items) {
         const o = n.items.value || n.items;
-        if (!Array.isArray(o) || (i = o[a.index], i == null)) return null;
+        if (!Array.isArray(o) || (i = o[r.index], i == null)) return null;
         continue;
-      } else if (a.index === void 0) {
-        if (i = n[a.key], i == null) return null;
+      } else if (r.index === void 0) {
+        if (i = n[r.key], i == null) return null;
         continue;
       }
-      if (i && a.index !== void 0 && i.items) {
+      if (i && r.index !== void 0 && i.items) {
         const o = i.items.value || i.items;
         if (!Array.isArray(o)) return null;
-        i = o[a.index];
-      } else if (i && a.index !== void 0 && !i.items)
+        i = o[r.index];
+      } else if (i && r.index !== void 0 && !i.items)
         return null;
       if (i == null) return null;
     }
     return i;
   }
 }
-class w extends F {
+function W(a) {
+  const { getChildren: e, ownErrors: t, disabled: s } = a, i = d(() => t.value.length > 0 ? !1 : e().every((h) => h.disabled.value || h.valid.value)), r = d(() => !i.value), n = d(() => e().some((h) => h.pending.value)), o = d(() => e().some((h) => h.touched.value)), l = d(() => e().some((h) => h.dirty.value)), u = d(() => {
+    const h = [...t.value];
+    for (const f of e())
+      h.push(...f.errors.value);
+    return h;
+  }), v = d(() => s?.value ? "disabled" : n.value ? "pending" : r.value ? "invalid" : "valid");
+  return {
+    valid: i,
+    invalid: r,
+    pending: n,
+    touched: o,
+    dirty: l,
+    errors: u,
+    status: v
+  };
+}
+function ie(a) {
+  return typeof a == "object" && a !== null && "getProxy" in a && typeof a.getProxy == "function";
+}
+function re(a, e) {
+  return new Proxy(a, {
+    get: (t, s) => {
+      if (s in t)
+        return t[s];
+      if (typeof s == "string" && e.has(s)) {
+        const i = e.get(s);
+        return i && ie(i) ? i.getProxy() : i;
+      }
+    },
+    set: (t, s, i) => typeof s == "string" && e.has(s) ? !1 : (t[s] = i, !0),
+    has: (t, s) => typeof s == "string" && e.has(s) ? !0 : s in t,
+    ownKeys: (t) => {
+      const s = Reflect.ownKeys(t), i = Array.from(e.keys());
+      return [.../* @__PURE__ */ new Set([...s, ...i])];
+    },
+    getOwnPropertyDescriptor: (t, s) => typeof s == "string" && e.has(s) ? { enumerable: !0, configurable: !0 } : Reflect.getOwnPropertyDescriptor(t, s)
+  });
+}
+class ae {
+  /**
+   * @param form - Форма для отправки
+   */
+  constructor(e) {
+    this.form = e;
+  }
+  /** Внутренний сигнал состояния отправки */
+  _submitting = g(!1);
+  /** Публичный read-only сигнал состояния отправки */
+  submitting = d(() => this._submitting.value);
+  /**
+   * Отправить форму
+   *
+   * Процесс:
+   * 1. Помечает все поля как touched (для отображения ошибок)
+   * 2. Валидирует форму
+   * 3. Если валидация успешна - вызывает onSubmit
+   * 4. Управляет состоянием submitting
+   *
+   * @param onSubmit - Callback для отправки данных
+   * @param options - Опции submit
+   * @returns Результат от onSubmit или null если валидация не пройдена
+   *
+   * @example
+   * ```typescript
+   * const result = await submitter.submit(async (values) => {
+   *   const response = await fetch('/api/form', {
+   *     method: 'POST',
+   *     body: JSON.stringify(values)
+   *   });
+   *   return response.json();
+   * });
+   *
+   * if (result === null) {
+   *   console.log('Форма не прошла валидацию');
+   * }
+   * ```
+   */
+  async submit(e, t) {
+    const { skipValidation: s = !1, skipTouch: i = !1 } = t || {};
+    if (i || this.form.markAsTouched(), !s && !await this.form.validate())
+      return null;
+    this._submitting.value = !0;
+    try {
+      return await e(this.form.getValue());
+    } finally {
+      this._submitting.value = !1;
+    }
+  }
+  /**
+   * Отправить форму с расширенным результатом
+   *
+   * В отличие от submit(), возвращает объект с информацией об успехе/ошибке
+   *
+   * @param onSubmit - Callback для отправки данных
+   * @param options - Опции submit
+   * @returns Объект SubmitResult с данными и статусом
+   *
+   * @example
+   * ```typescript
+   * const result = await submitter.submitWithResult(async (values) => {
+   *   return await api.saveForm(values);
+   * });
+   *
+   * if (result.success) {
+   *   console.log('Сохранено:', result.data);
+   * } else if (result.error) {
+   *   console.error('Ошибка:', result.error.message);
+   * } else {
+   *   console.log('Валидация не пройдена');
+   * }
+   * ```
+   */
+  async submitWithResult(e, t) {
+    const { skipValidation: s = !1, skipTouch: i = !1 } = t || {};
+    if (i || this.form.markAsTouched(), !s && !await this.form.validate())
+      return { success: !1, data: null };
+    this._submitting.value = !0;
+    try {
+      return { success: !0, data: await e(this.form.getValue()) };
+    } catch (r) {
+      return {
+        success: !1,
+        data: null,
+        error: r instanceof Error ? r : new Error(String(r))
+      };
+    } finally {
+      this._submitting.value = !1;
+    }
+  }
+  /**
+   * Проверить, идет ли отправка формы
+   */
+  isSubmitting() {
+    return this._submitting.value;
+  }
+}
+class k extends C {
   // ============================================================================
   // Приватные поля
   // ============================================================================
-  id = J();
+  id = crypto.randomUUID();
   /**
    * Коллекция полей формы (упрощённый Map вместо FieldRegistry)
    */
@@ -1395,7 +1614,7 @@ class w extends F {
   /**
    * Менеджер подписок для централизованного cleanup
    */
-  disposers = new C();
+  disposers = new D();
   /**
    * Ссылка на Proxy-инстанс для использования в BehaviorContext
    */
@@ -1403,32 +1622,35 @@ class w extends F {
   /**
    * Навигатор для работы с путями к полям
    */
-  pathNavigator = new Z();
+  pathNavigator = new se();
   /**
    * Фабрика для создания узлов формы
    */
-  nodeFactory = new ee();
+  nodeFactory = new ne();
   /**
    * Реестр валидаторов для этой формы
+   * Может быть инжектирован через config._validationRegistry для тестирования
    */
-  validationRegistry = new W();
+  validationRegistry;
   /**
    * Реестр behaviors для этой формы
+   * Может быть инжектирован через config._behaviorRegistry для тестирования
    */
-  behaviorRegistry = new z();
+  behaviorRegistry;
   /**
    * Аппликатор для применения валидаторов к форме
    */
-  validationApplicator = new X(this);
+  validationApplicator = new te(this);
   // ============================================================================
   // Приватные сигналы состояния (inline из StateManager)
   // ============================================================================
-  /** Флаг отправки формы */
-  _submitting = y(!1);
+  /** Управление отправкой формы */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  formSubmitter;
   /** Флаг disabled состояния */
-  _disabled = y(!1);
+  _disabled = g(!1);
   /** Form-level validation errors */
-  _formErrors = y([]);
+  _formErrors = g([]);
   // ============================================================================
   // Публичные computed signals
   // ============================================================================
@@ -1442,76 +1664,56 @@ class w extends F {
   status;
   submitting;
   constructor(e) {
-    super();
-    const t = "form" in e, r = t ? e.form : e, i = t ? e.behavior : void 0, a = t ? e.validation : void 0;
-    for (const [n, o] of Object.entries(r)) {
-      const l = this.createNode(o);
-      this._fields.set(n, l);
+    super(), this.formSubmitter = new ae(this);
+    const t = "form" in e, s = t ? e : void 0, i = t ? e.form : e, r = t ? e.behavior : void 0, n = t ? e.validation : void 0;
+    this.validationRegistry = s?._validationRegistry ?? new K(), this.behaviorRegistry = s?._behaviorRegistry ?? new H();
+    for (const [l, u] of Object.entries(i)) {
+      const v = this.createNode(u);
+      this._fields.set(l, v);
     }
-    this.value = u(() => {
-      const n = {};
-      return this._fields.forEach((o, l) => {
-        n[l] = o.value.value;
-      }), n;
-    }), this.valid = u(() => this._formErrors.value.length > 0 ? !1 : Array.from(this._fields.values()).every((n) => n.valid.value)), this.invalid = u(() => !this.valid.value), this.pending = u(
-      () => Array.from(this._fields.values()).some((n) => n.pending.value)
-    ), this.touched = u(
-      () => Array.from(this._fields.values()).some((n) => n.touched.value)
-    ), this.dirty = u(
-      () => Array.from(this._fields.values()).some((n) => n.dirty.value)
-    ), this.errors = u(() => {
-      const n = [...this._formErrors.value];
-      return this._fields.forEach((o) => {
-        n.push(...o.errors.value);
-      }), n;
-    }), this.status = u(() => this._disabled.value ? "disabled" : this.pending.value ? "pending" : this.invalid.value ? "invalid" : "valid"), this.submitting = u(() => this._submitting.value), this._proxyInstance = this.buildProxy(), i && this.applyBehaviorSchema(i), a && this.applyValidationSchema(a);
-  }
-  // ============================================================================
-  // Приватный метод для создания Proxy (inline из ProxyBuilder)
+    this.value = d(() => {
+      const l = {};
+      return this._fields.forEach((u, v) => {
+        l[v] = u.value.value;
+      }), l;
+    });
+    const o = W({
+      getChildren: () => Array.from(this._fields.values()),
+      ownErrors: this._formErrors,
+      disabled: this._disabled
+    });
+    this.valid = o.valid, this.invalid = o.invalid, this.pending = o.pending, this.touched = o.touched, this.dirty = o.dirty, this.errors = o.errors, this.status = o.status, this.submitting = this.formSubmitter.submitting, r && this.applyBehaviorSchema(r), n && this.applyValidationSchema(n);
+  }
+  // ============================================================================
+  // Приватный метод для создания Proxy
   // ============================================================================
   /**
    * Создать Proxy для типобезопасного доступа к полям
+   * @see buildFormProxy
    */
   buildProxy() {
-    const e = this;
-    return new Proxy(this, {
-      get: (t, r) => {
-        if (r in t)
-          return t[r];
-        if (typeof r == "string" && e._fields.has(r)) {
-          const i = e._fields.get(r);
-          return i && typeof i.getProxy == "function" ? i.getProxy() : i;
-        }
-      },
-      set: (t, r, i) => typeof r == "string" && e._fields.has(r) ? !1 : (t[r] = i, !0),
-      has: (t, r) => typeof r == "string" && e._fields.has(r) ? !0 : r in t,
-      ownKeys: (t) => {
-        const r = Reflect.ownKeys(t), i = Array.from(e._fields.keys());
-        return [.../* @__PURE__ */ new Set([...r, ...i])];
-      },
-      getOwnPropertyDescriptor: (t, r) => typeof r == "string" && e._fields.has(r) ? { enumerable: !0, configurable: !0 } : Reflect.getOwnPropertyDescriptor(t, r)
-    });
+    return re(this, this._fields);
   }
   // ============================================================================
   // Реализация абстрактных методов FormNode
   // ============================================================================
   getValue() {
     const e = {};
-    return this._fields.forEach((t, r) => {
-      e[r] = t.getValue();
+    return this._fields.forEach((t, s) => {
+      e[s] = t.getValue();
     }), e;
   }
   setValue(e, t) {
-    for (const [r, i] of Object.entries(e)) {
-      const a = this._fields.get(r);
-      a && a.setValue(i, t);
+    for (const [s, i] of Object.entries(e)) {
+      const r = this._fields.get(s);
+      r && r.setValue(i, t);
     }
   }
   patchValue(e) {
     j(() => {
-      for (const [t, r] of Object.entries(e)) {
+      for (const [t, s] of Object.entries(e)) {
         const i = this._fields.get(t);
-        i && r !== void 0 && i.setValue(r, { emitEvent: !1 });
+        i && s !== void 0 && i.setValue(s, { emitEvent: !1 });
       }
     });
   }
@@ -1533,8 +1735,8 @@ class w extends F {
    * ```
    */
   reset(e) {
-    this._fields.forEach((t, r) => {
-      const i = e?.[r];
+    this._fields.forEach((t, s) => {
+      const i = e?.[s];
       t.reset(i);
     });
   }
@@ -1549,7 +1751,9 @@ class w extends F {
   async validate() {
     this.clearErrors(), await Promise.all(Array.from(this._fields.values()).map((t) => t.validate()));
     const e = this.validationRegistry.getValidators();
-    return e && e.length > 0 && await this.applyContextualValidators(e), Array.from(this._fields.values()).every((t) => t.valid.value);
+    return e && e.length > 0 && await this.applyContextualValidators(e), Array.from(this._fields.values()).every(
+      (t) => t.valid.value || t.disabled.value
+    );
   }
   /**
    * Установить form-level validation errors
@@ -1602,7 +1806,7 @@ class w extends F {
    * ```
    */
   getProxy() {
-    return this._proxyInstance || this;
+    return this._proxyInstance || (this._proxyInstance = this.buildProxy()), this._proxyInstance;
   }
   /**
    * Получить все поля формы как итератор
@@ -1630,16 +1834,23 @@ class w extends F {
   // ============================================================================
   /**
    * Отправить форму
+   *
+   * @param onSubmit - Callback для отправки данных
+   * @param options - Опции submit (skipValidation, skipTouch)
+   * @returns Результат от onSubmit или null если валидация не пройдена
    */
-  async submit(e) {
-    if (this.markAsTouched(), !await this.validate())
-      return null;
-    this._submitting.value = !0;
-    try {
-      return await e(this.getValue());
-    } finally {
-      this._submitting.value = !1;
-    }
+  async submit(e, t) {
+    return this.formSubmitter.submit(e, t);
+  }
+  /**
+   * Отправить форму с расширенным результатом
+   *
+   * @param onSubmit - Callback для отправки данных
+   * @param options - Опции submit
+   * @returns Объект SubmitResult с данными, статусом и возможной ошибкой
+   */
+  async submitWithResult(e, t) {
+    return this.formSubmitter.submitWithResult(e, t);
   }
   /**
    * Применить validation schema к форме
@@ -1650,10 +1861,10 @@ class w extends F {
   applyValidationSchema(e) {
     this.validationRegistry.beginRegistration();
     try {
-      const t = D();
+      const t = I();
       e(t);
-      const r = this.getProxy();
-      this.validationRegistry.endRegistration(r);
+      const s = this.getProxy();
+      this.validationRegistry.endRegistration(s);
     } catch (t) {
       throw console.error("Error applying validation schema:", t), t;
     }
@@ -1665,7 +1876,7 @@ class w extends F {
   applyBehaviorSchema(e) {
     this.behaviorRegistry.beginRegistration();
     try {
-      const t = D();
+      const t = I();
       return e(t), this.behaviorRegistry.endRegistration(this.getProxy()).cleanup;
     } catch (t) {
       throw console.error("Error applying behavior schema:", t), t;
@@ -1706,18 +1917,18 @@ class w extends F {
     const t = this.pathNavigator.parsePath(e);
     if (t.length === 0)
       return;
-    let r = this;
+    let s = this;
     for (const i of t) {
-      if (!(r instanceof w) || (r = r.getField(i.key), !r)) return;
+      if (!(s instanceof k) || (s = s.getField(i.key), !s)) return;
       if (i.index !== void 0)
-        if ("at" in r && "length" in r && typeof r.at == "function") {
-          const a = r.at(i.index);
-          if (!a) return;
-          r = a;
+        if ("at" in s && "length" in s && typeof s.at == "function") {
+          const r = s.at(i.index);
+          if (!r) return;
+          s = r;
         } else
           return;
     }
-    return r;
+    return s;
   }
   /**
    * Применить contextual валидаторы к полям
@@ -1761,15 +1972,16 @@ class w extends F {
   /**
    * Связывает два поля: при изменении source автоматически обновляется target
    */
-  linkFields(e, t, r) {
-    const i = this._fields.get(e), a = this._fields.get(t);
-    if (!i || !a)
-      return () => {
-      };
-    const n = E(() => {
-      const l = i.value.value, h = r ? r(l) : l;
-      a.setValue(h, { emitEvent: !1 });
-    }), o = S("linkFields");
+  linkFields(e, t, s) {
+    const i = this._fields.get(e), r = this._fields.get(t);
+    if (!i || !r) {
+      const l = i ? t : e;
+      throw new Error(`GroupNode.linkFields: field "${String(l)}" not found`);
+    }
+    const n = m(() => {
+      const l = i.value.value, u = s ? s(l) : l;
+      r.setValue(u, { emitEvent: !1 });
+    }), o = A(w.LinkFields);
     return this.disposers.add(o, n);
   }
   /**
@@ -1800,15 +2012,14 @@ class w extends F {
    * ```
    */
   watchField(e, t) {
-    const r = this.getFieldByPath(e);
-    if (!r)
-      return () => {
-      };
-    const i = E(() => {
-      const n = r.value.value;
+    const s = this.getFieldByPath(e);
+    if (!s)
+      throw new Error(`GroupNode.watchField: field "${e}" not found`);
+    const i = m(() => {
+      const n = s.value.value;
       t(n);
-    }), a = S("watchField");
-    return this.disposers.add(a, i);
+    }), r = A(w.WatchField);
+    return this.disposers.add(r, i);
   }
   /**
    * Hook: вызывается после disable()
@@ -1831,7 +2042,7 @@ class w extends F {
     });
   }
 }
-class N extends F {
+class L extends C {
   // ============================================================================
   // Приватные поля
   // ============================================================================
@@ -1842,9 +2053,9 @@ class N extends F {
    * Менеджер подписок для централизованного cleanup
    * Использует SubscriptionManager вместо массива для управления подписками
    */
-  disposers = new C();
+  disposers = new D();
   /** Array-level validation errors (e.g., "минимум 1 элемент") */
-  _arrayErrors = y([]);
+  _arrayErrors = g([]);
   // ============================================================================
   // Приватные поля для сохранения схем
   // ============================================================================
@@ -1866,15 +2077,15 @@ class N extends F {
   // Конструктор
   // ============================================================================
   constructor(e, t = []) {
-    super(), this.itemSchema = e, this.initialItems = t, this.items = y([]);
-    for (const r of t)
-      this.push(r);
-    this.length = u(() => this.items.value.length), this.value = u(() => this.items.value.map((r) => r.value.value)), this.valid = u(() => this._arrayErrors.value.length > 0 ? !1 : this.items.value.every((r) => r.valid.value)), this.invalid = u(() => !this.valid.value), this.pending = u(() => this.items.value.some((r) => r.pending.value)), this.touched = u(() => this.items.value.some((r) => r.touched.value)), this.dirty = u(() => this.items.value.some((r) => r.dirty.value)), this.errors = u(() => {
-      const r = [...this._arrayErrors.value];
-      return this.items.value.forEach((i) => {
-        r.push(...i.errors.value);
-      }), r;
-    }), this.status = u(() => this.pending.value ? "pending" : this.invalid.value ? "invalid" : "valid");
+    super(), this.itemSchema = e, this.initialItems = t, this.items = g([]);
+    for (const i of t)
+      this.push(i);
+    this.length = d(() => this.items.value.length), this.value = d(() => this.items.value.map((i) => i.value.value));
+    const s = W({
+      getChildren: () => this.items.value,
+      ownErrors: this._arrayErrors
+    });
+    this.valid = s.valid, this.invalid = s.invalid, this.pending = s.pending, this.touched = s.touched, this.dirty = s.dirty, this.errors = s.errors, this.status = s.status;
   }
   // ============================================================================
   // CRUD операции
@@ -1890,9 +2101,23 @@ class N extends F {
   /**
    * Удалить элемент по индексу
    * @param index - Индекс элемента для удаления
+   *
+   * @remarks
+   * Вызывает dispose() на удаляемом элементе для очистки подписок
    */
   removeAt(e) {
-    e < 0 || e >= this.items.value.length || (this.items.value = this.items.value.filter((t, r) => r !== e));
+    if (e < 0 || e >= this.items.value.length) {
+      S.handle(
+        new Error(
+          `ArrayNode.removeAt: index ${e} out of bounds (length: ${this.items.value.length})`
+        ),
+        "ArrayNode.removeAt",
+        V.LOG
+      );
+      return;
+    }
+    const t = this.items.value[e];
+    this.items.value = this.items.value.filter((s, i) => i !== e), t && "dispose" in t && typeof t.dispose == "function" && t.dispose();
   }
   /**
    * Вставить элемент в массив
@@ -1900,16 +2125,30 @@ class N extends F {
    * @param initialValue - Начальные значения для нового элемента
    */
   insert(e, t) {
-    if (e < 0 || e > this.items.value.length)
+    if (e < 0 || e > this.items.value.length) {
+      S.handle(
+        new Error(
+          `ArrayNode.insert: index ${e} out of bounds (length: ${this.items.value.length})`
+        ),
+        "ArrayNode.insert",
+        V.LOG
+      );
       return;
-    const r = this.createItem(t), i = [...this.items.value];
-    i.splice(e, 0, r), this.items.value = i;
+    }
+    const s = this.createItem(t), i = [...this.items.value];
+    i.splice(e, 0, s), this.items.value = i;
   }
   /**
    * Удалить все элементы массива
+   *
+   * @remarks
+   * Вызывает dispose() на всех элементах для очистки подписок
    */
   clear() {
-    this.items.value = [];
+    const e = [...this.items.value];
+    this.items.value = [], e.forEach((t) => {
+      "dispose" in t && typeof t.dispose == "function" && t.dispose();
+    });
   }
   /**
    * Получить элемент по индексу
@@ -1928,12 +2167,13 @@ class N extends F {
     return this.items.value.map((e) => e.getValue());
   }
   setValue(e, t) {
-    this.clear(), e.forEach((r) => this.push(r)), t?.emitEvent !== !1 && this.validate().catch(() => {
+    this.clear(), e.forEach((s) => this.push(s)), t?.emitEvent !== !1 && this.validate().catch((s) => {
+      S.handle(s, "ArrayNode.setValue", V.LOG);
     });
   }
   patchValue(e) {
-    e.forEach((t, r) => {
-      this.items.value[r] && t !== void 0 && this.items.value[r].patchValue(t);
+    e.forEach((t, s) => {
+      this.items.value[s] && t !== void 0 && this.items.value[s].patchValue(t);
     });
   }
   /**
@@ -2061,9 +2301,9 @@ class N extends F {
    * @param callback - Функция, вызываемая для каждого элемента с типизированным GroupNode proxy
    */
   forEach(e) {
-    this.items.value.forEach((t, r) => {
+    this.items.value.forEach((t, s) => {
       const i = t.getProxy();
-      e(i, r);
+      e(i, s);
     });
   }
   /**
@@ -2072,9 +2312,9 @@ class N extends F {
    * @returns Новый массив результатов
    */
   map(e) {
-    return this.items.value.map((t, r) => {
+    return this.items.value.map((t, s) => {
       const i = t.getProxy();
-      return e(i, r);
+      return e(i, s);
     });
   }
   // ============================================================================
@@ -2086,7 +2326,7 @@ class N extends F {
    */
   createItem(e) {
     if (this.isGroupSchema(this.itemSchema)) {
-      const t = new w(this.itemSchema);
+      const t = new k(this.itemSchema);
       return e && t.patchValue(e), this.validationSchemaFn && "applyValidationSchema" in t && t.applyValidationSchema(this.validationSchemaFn), this.behaviorSchemaFn && "applyBehaviorSchema" in t && t.applyBehaviorSchema(this.behaviorSchemaFn), t;
     }
     throw new Error(
@@ -2173,14 +2413,14 @@ class N extends F {
    * ```
    */
   watchItems(e, t) {
-    const r = E(() => {
-      const a = this.items.value.map((n) => {
-        if (n instanceof w)
+    const s = m(() => {
+      const r = this.items.value.map((n) => {
+        if (n instanceof k)
           return n.getFieldByPath(e)?.value.value;
       });
-      t(a);
-    }), i = S("watchItems");
-    return this.disposers.add(i, r);
+      t(r);
+    }), i = A(w.WatchItems);
+    return this.disposers.add(i, s);
   }
   /**
    * Подписка на изменение длины массива
@@ -2205,11 +2445,11 @@ class N extends F {
    * ```
    */
   watchLength(e) {
-    const t = E(() => {
+    const t = m(() => {
       const i = this.length.value;
       e(i);
-    }), r = S("watchLength");
-    return this.disposers.add(r, t);
+    }), s = A(w.WatchLength);
+    return this.disposers.add(s, t);
   }
   /**
    * Очистить все ресурсы узла
@@ -2272,7 +2512,7 @@ class N extends F {
     });
   }
 }
-class ee {
+class ne {
   /**
    * Создает узел формы на основе конфигурации
    *
@@ -2322,16 +2562,16 @@ class ee {
     if (Array.isArray(e) && e.length >= 1)
       return this.createArrayNodeFromArray(e);
     if (this.isFieldConfig(e))
-      return new Q(e);
+      return new ee(e);
     if (this.isArrayConfig(e)) {
       const t = e;
-      return new N(
+      return new L(
         t.schema,
         t.initialItems
       );
     }
     if (this.isGroupConfig(e))
-      return new w(e);
+      return new k(e);
     throw new Error(
       `NodeFactory: Unknown node config. Expected FieldConfig, GroupConfig, or ArrayConfig, but got: ${JSON.stringify(
         e
@@ -2365,11 +2605,11 @@ class ee {
    */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   createArrayNodeFromArray(e) {
-    const [t, ...r] = e, i = [];
+    const [t, ...s] = e, i = [];
     this.isGroupConfig(t) && i.push(this.extractValues(t));
-    for (const a of r)
-      this.isGroupConfig(a) ? i.push(this.extractValues(a)) : i.push(a);
-    return new N(t, i);
+    for (const r of s)
+      this.isGroupConfig(r) ? i.push(this.extractValues(r)) : i.push(r);
+    return new L(t, i);
   }
   /**
    * Извлечь значения из схемы (рекурсивно)
@@ -2407,8 +2647,8 @@ class ee {
       return e.map((t) => this.extractValues(t));
     if (this.isGroupConfig(e)) {
       const t = {};
-      for (const [r, i] of Object.entries(e))
-        t[r] = this.extractValues(i);
+      for (const [s, i] of Object.entries(e))
+        t[s] = this.extractValues(i);
       return t;
     }
     return e;
@@ -2488,299 +2728,334 @@ class ee {
     return e != null && typeof e == "object" && !this.isFieldConfig(e) && !this.isArrayConfig(e);
   }
 }
-class pe {
+function ge(a) {
+  return new k(a).getProxy();
+}
+class be {
   /**
-   * Создать Debouncer с заданной задержкой
+   * @param form - Форма для наблюдения
+   * @param options - Опции observer
+   */
+  constructor(e, t) {
+    this.form = e, this.options = {
+      enableLogging: !1,
+      eventTypes: ["value", "status", "errors", "touched", "dirty"],
+      pathFilter: [],
+      ...t
+    };
+  }
+  listeners = /* @__PURE__ */ new Set();
+  disposers = [];
+  options;
+  /**
+   * Подписаться на события изменения
    *
-   * @param delay Задержка в миллисекундах (0 = без задержки)
+   * @param callback - Функция обработки события
+   * @returns Функция отписки
    *
    * @example
    * ```typescript
-   * const debouncer = new Debouncer(300); // 300мс задержка
-   * const immediate = new Debouncer(0);  // Без задержки
+   * const unsubscribe = observer.subscribe((event) => {
+   *   // Отправить событие в analytics
+   *   analytics.track('form_change', event);
+   * });
    * ```
    */
-  constructor(e) {
-    this.delay = e;
+  subscribe(e) {
+    return this.listeners.add(e), () => this.listeners.delete(e);
   }
   /**
-   * Таймер для отложенного выполнения
-   * @private
-   */
-  timer;
-  /**
-   * Отложить выполнение функции
+   * Включить трассировку формы
    *
-   * Если вызывается повторно до истечения delay, предыдущий вызов отменяется
-   * и таймер перезапускается.
+   * Подписывается на изменения основных сигналов формы
+   * и вызывает listeners при каждом изменении
    *
-   * @param fn Функция для выполнения (может быть async)
-   * @returns Promise, который разрешается результатом функции
+   * @returns Функция для отключения трассировки
    *
    * @example
    * ```typescript
-   * const debouncer = new Debouncer(300);
-   *
-   * // Первый вызов - запланирован через 300мс
-   * debouncer.debounce(async () => console.log('First'));
+   * const dispose = observer.enableTracing();
    *
-   * // Второй вызов через 100мс - отменяет первый, запланирован через 300мс
-   * debouncer.debounce(async () => console.log('Second'));
-   *
-   * // Через 300мс выведет только: "Second"
+   * // Позже, для отключения
+   * dispose();
    * ```
    */
-  async debounce(e) {
-    return new Promise((t, r) => {
-      if (this.timer && clearTimeout(this.timer), this.delay === 0) {
-        Promise.resolve().then(() => e()).then(t).catch(r);
-        return;
-      }
-      this.timer = setTimeout(async () => {
-        try {
-          const i = await e();
-          t(i);
-        } catch (i) {
-          r(i);
-        }
-      }, this.delay);
-    });
+  enableTracing() {
+    if (this.shouldTrack("value")) {
+      let e = this.form.value.value;
+      const t = m(() => {
+        const s = this.form.value.value;
+        s !== e && (this.emit({
+          type: "value",
+          path: "",
+          timestamp: Date.now(),
+          oldValue: e,
+          newValue: s
+        }), e = s);
+      });
+      this.disposers.push(t);
+    }
+    if (this.shouldTrack("status")) {
+      let e = this.form.status.value;
+      const t = m(() => {
+        const s = this.form.status.value;
+        s !== e && (this.emit({
+          type: "status",
+          path: "",
+          timestamp: Date.now(),
+          oldValue: e,
+          newValue: s
+        }), e = s);
+      });
+      this.disposers.push(t);
+    }
+    if (this.shouldTrack("errors")) {
+      let e = this.form.errors.value;
+      const t = m(() => {
+        const s = this.form.errors.value;
+        s !== e && (this.emit({
+          type: "errors",
+          path: "",
+          timestamp: Date.now(),
+          oldValue: e,
+          newValue: s
+        }), e = s);
+      });
+      this.disposers.push(t);
+    }
+    if (this.shouldTrack("touched")) {
+      let e = this.form.touched.value;
+      const t = m(() => {
+        const s = this.form.touched.value;
+        s !== e && (this.emit({
+          type: "touched",
+          path: "",
+          timestamp: Date.now(),
+          oldValue: e,
+          newValue: s
+        }), e = s);
+      });
+      this.disposers.push(t);
+    }
+    if (this.shouldTrack("dirty")) {
+      let e = this.form.dirty.value;
+      const t = m(() => {
+        const s = this.form.dirty.value;
+        s !== e && (this.emit({
+          type: "dirty",
+          path: "",
+          timestamp: Date.now(),
+          oldValue: e,
+          newValue: s
+        }), e = s);
+      });
+      this.disposers.push(t);
+    }
+    return () => {
+      this.disposers.forEach((e) => e()), this.disposers = [];
+    };
   }
   /**
-   * Отменить отложенное выполнение
+   * Наблюдать за конкретным полем
    *
-   * Если есть запланированный вызов, он будет отменен и не выполнится.
-   * Promise из debounce() никогда не разрешится.
+   * @param path - Путь к полю
+   * @returns Функция для отключения наблюдения
    *
    * @example
    * ```typescript
-   * const debouncer = new Debouncer(300);
-   *
-   * debouncer.debounce(async () => {
-   *   console.log('This will not execute');
-   * });
-   *
-   * debouncer.cancel(); // Отменяем вызов
+   * // Наблюдать за полем email
+   * const dispose = observer.watchField('email');
    * ```
    */
-  cancel() {
-    this.timer && (clearTimeout(this.timer), this.timer = void 0);
+  watchField(e) {
+    const t = this.form.getFieldByPath(e);
+    if (!t)
+      return () => {
+      };
+    const s = [];
+    if (this.shouldTrack("value")) {
+      let i = t.value.value;
+      const r = m(() => {
+        const n = t.value.value;
+        n !== i && (this.emit({
+          type: "value",
+          path: e,
+          timestamp: Date.now(),
+          oldValue: i,
+          newValue: n
+        }), i = n);
+      });
+      s.push(r);
+    }
+    if (this.shouldTrack("status")) {
+      let i = t.status.value;
+      const r = m(() => {
+        const n = t.status.value;
+        n !== i && (this.emit({
+          type: "status",
+          path: e,
+          timestamp: Date.now(),
+          oldValue: i,
+          newValue: n
+        }), i = n);
+      });
+      s.push(r);
+    }
+    return () => s.forEach((i) => i());
   }
   /**
-   * Выполнить функцию немедленно, отменив любой отложенный вызов
-   *
-   * Полезно когда нужно принудительно выполнить действие сейчас,
-   * игнорируя debounce.
-   *
-   * @param fn Функция для немедленного выполнения
-   * @returns Promise с результатом функции
-   *
-   * @example
-   * ```typescript
-   * const debouncer = new Debouncer(300);
-   *
-   * // Запланировано через 300мс
-   * debouncer.debounce(async () => console.log('Delayed'));
-   *
-   * // Отменяем отложенный и выполняем немедленно
-   * await debouncer.flush(async () => console.log('Immediate'));
-   * // Выведет: "Immediate" (сразу)
-   * // "Delayed" не выполнится (отменен)
-   * ```
+   * Отправить событие всем listeners
    */
-  async flush(e) {
-    return this.cancel(), await e();
+  emit(e) {
+    this.matchesPathFilter(e.path) && (this.options.enableLogging && console.log(`[FormObserver] ${e.type} at "${e.path || "root"}":`, e.newValue), this.listeners.forEach((t) => {
+      try {
+        t(e);
+      } catch {
+      }
+    }));
   }
   /**
-   * Проверить, есть ли активный (запланированный) вызов
-   *
-   * @returns true если есть запланированный вызов
-   *
-   * @example
-   * ```typescript
-   * const debouncer = new Debouncer(300);
-   *
-   * console.log(debouncer.isPending()); // false
-   *
-   * debouncer.debounce(() => console.log('Test'));
-   * console.log(debouncer.isPending()); // true
-   *
-   * // Через 300мс
-   * console.log(debouncer.isPending()); // false
-   * ```
+   * Проверить, нужно ли отслеживать тип события
    */
-  isPending() {
-    return this.timer !== void 0;
+  shouldTrack(e) {
+    return this.options.eventTypes.includes(e);
+  }
+  /**
+   * Проверить, соответствует ли путь фильтру
+   */
+  matchesPathFilter(e) {
+    const { pathFilter: t } = this.options;
+    return !t || Array.isArray(t) && t.length === 0 ? !0 : t instanceof RegExp ? t.test(e) : t.includes(e);
+  }
+  /**
+   * Очистить все подписки и disposers
+   */
+  dispose() {
+    this.disposers.forEach((e) => e()), this.disposers = [], this.listeners.clear();
   }
 }
-function ye(s) {
-  return new w(s).getProxy();
-}
-function te(s) {
-  return {
-    type: "static",
-    load: async () => ({
-      items: s,
-      totalCount: s.length
-    })
-  };
-}
-function re(s) {
-  let e = null;
-  return {
-    type: "preload",
-    load: async (t) => {
-      if (!e) {
-        const r = await s(t);
-        e = {
-          items: r,
-          totalCount: r.length
-        };
-      }
-      return e;
-    }
-  };
-}
-function ie(s) {
-  return {
-    type: "partial",
-    load: async (e) => {
-      const t = await s(e);
-      return {
-        items: t,
-        totalCount: t.length
-        // Можно расширить для поддержки серверной пагинации
-      };
-    }
-  };
-}
-const me = {
-  static: te,
-  preload: re,
-  partial: ie
-};
-var A = { exports: {} }, x = {};
-var I;
-function se() {
-  if (I) return x;
-  I = 1;
-  var s = L;
-  function e(c, f) {
-    return c === f && (c !== 0 || 1 / c === 1 / f) || c !== c && f !== f;
-  }
-  var t = typeof Object.is == "function" ? Object.is : e, r = s.useState, i = s.useEffect, a = s.useLayoutEffect, n = s.useDebugValue;
-  function o(c, f) {
-    var d = f(), v = r({ inst: { value: d, getSnapshot: f } }), p = v[0].inst, g = v[1];
-    return a(
+var x = { exports: {} }, T = {};
+var B;
+function oe() {
+  if (B) return T;
+  B = 1;
+  var a = U;
+  function e(h, f) {
+    return h === f && (h !== 0 || 1 / h === 1 / f) || h !== h && f !== f;
+  }
+  var t = typeof Object.is == "function" ? Object.is : e, s = a.useState, i = a.useEffect, r = a.useLayoutEffect, n = a.useDebugValue;
+  function o(h, f) {
+    var c = f(), p = s({ inst: { value: c, getSnapshot: f } }), y = p[0].inst, E = p[1];
+    return r(
       function() {
-        p.value = d, p.getSnapshot = f, l(p) && g({ inst: p });
+        y.value = c, y.getSnapshot = f, l(y) && E({ inst: y });
       },
-      [c, d, f]
+      [h, c, f]
     ), i(
       function() {
-        return l(p) && g({ inst: p }), c(function() {
-          l(p) && g({ inst: p });
+        return l(y) && E({ inst: y }), h(function() {
+          l(y) && E({ inst: y });
         });
       },
-      [c]
-    ), n(d), d;
+      [h]
+    ), n(c), c;
   }
-  function l(c) {
-    var f = c.getSnapshot;
-    c = c.value;
+  function l(h) {
+    var f = h.getSnapshot;
+    h = h.value;
     try {
-      var d = f();
-      return !t(c, d);
+      var c = f();
+      return !t(h, c);
     } catch {
       return !0;
     }
   }
-  function h(c, f) {
+  function u(h, f) {
     return f();
   }
-  var m = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? h : o;
-  return x.useSyncExternalStore = s.useSyncExternalStore !== void 0 ? s.useSyncExternalStore : m, x;
+  var v = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? u : o;
+  return T.useSyncExternalStore = a.useSyncExternalStore !== void 0 ? a.useSyncExternalStore : v, T;
 }
-var P = {};
-var M;
-function ae() {
-  return M || (M = 1, process.env.NODE_ENV !== "production" && (function() {
-    function s(d, v) {
-      return d === v && (d !== 0 || 1 / d === 1 / v) || d !== d && v !== v;
+var O = {};
+var G;
+function le() {
+  return G || (G = 1, process.env.NODE_ENV !== "production" && (function() {
+    function a(c, p) {
+      return c === p && (c !== 0 || 1 / c === 1 / p) || c !== c && p !== p;
     }
-    function e(d, v) {
-      m || i.startTransition === void 0 || (m = !0, console.error(
+    function e(c, p) {
+      v || i.startTransition === void 0 || (v = !0, console.error(
         "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
       ));
-      var p = v();
-      if (!c) {
-        var g = v();
-        a(p, g) || (console.error(
+      var y = p();
+      if (!h) {
+        var E = p();
+        r(y, E) || (console.error(
           "The result of getSnapshot should be cached to avoid an infinite loop"
-        ), c = !0);
+        ), h = !0);
       }
-      g = n({
-        inst: { value: p, getSnapshot: v }
+      E = n({
+        inst: { value: y, getSnapshot: p }
       });
-      var _ = g[0].inst, k = g[1];
+      var _ = E[0].inst, F = E[1];
       return l(
         function() {
-          _.value = p, _.getSnapshot = v, t(_) && k({ inst: _ });
+          _.value = y, _.getSnapshot = p, t(_) && F({ inst: _ });
         },
-        [d, p, v]
+        [c, y, p]
       ), o(
         function() {
-          return t(_) && k({ inst: _ }), d(function() {
-            t(_) && k({ inst: _ });
+          return t(_) && F({ inst: _ }), c(function() {
+            t(_) && F({ inst: _ });
           });
         },
-        [d]
-      ), h(p), p;
+        [c]
+      ), u(y), y;
     }
-    function t(d) {
-      var v = d.getSnapshot;
-      d = d.value;
+    function t(c) {
+      var p = c.getSnapshot;
+      c = c.value;
       try {
-        var p = v();
-        return !a(d, p);
+        var y = p();
+        return !r(c, y);
       } catch {
         return !0;
       }
     }
-    function r(d, v) {
-      return v();
+    function s(c, p) {
+      return p();
     }
     typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
-    var i = L, a = typeof Object.is == "function" ? Object.is : s, n = i.useState, o = i.useEffect, l = i.useLayoutEffect, h = i.useDebugValue, m = !1, c = !1, f = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? r : e;
-    P.useSyncExternalStore = i.useSyncExternalStore !== void 0 ? i.useSyncExternalStore : f, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
-  })()), P;
+    var i = U, r = typeof Object.is == "function" ? Object.is : a, n = i.useState, o = i.useEffect, l = i.useLayoutEffect, u = i.useDebugValue, v = !1, h = !1, f = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? s : e;
+    O.useSyncExternalStore = i.useSyncExternalStore !== void 0 ? i.useSyncExternalStore : f, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), O;
 }
-var B;
-function ne() {
-  return B || (B = 1, process.env.NODE_ENV === "production" ? A.exports = se() : A.exports = ae()), A.exports;
+var $;
+function ue() {
+  return $ || ($ = 1, process.env.NODE_ENV === "production" ? x.exports = oe() : x.exports = le()), x.exports;
 }
-var U = ne();
-function oe(s, e) {
-  if (s === e) return !0;
-  if (s.length !== e.length) return !1;
-  for (let t = 0; t < s.length; t++)
-    if (s[t] !== e[t]) return !1;
+var R = ue();
+function he(a, e) {
+  if (a === e) return !0;
+  if (a.length !== e.length) return !1;
+  for (let t = 0; t < a.length; t++)
+    if (a[t] !== e[t]) return !1;
   return !0;
 }
-function $(s, e, t) {
-  const r = G(null);
-  if (r.current === null) {
+function q(a, e, t) {
+  const s = P(null);
+  if (s.current === null) {
     const n = {};
-    for (const o in s)
-      n[o] = s[o].value;
-    r.current = { ...n, __snapshot: null };
+    for (const o in a)
+      n[o] = a[o].value;
+    s.current = { ...n, __snapshot: null };
   }
   const i = b(
     (n) => {
       let o = !0;
-      return E(() => {
-        for (const h in s)
-          s[h].value;
+      return m(() => {
+        for (const u in a)
+          a[u].value;
         if (o) {
           o = !1;
           return;
@@ -2788,43 +3063,43 @@ function $(s, e, t) {
         n();
       });
     },
-    [s]
-  ), a = b(() => {
-    const n = r.current, o = {};
-    for (const h in s)
-      o[h] = s[h].value;
+    [a]
+  ), r = b(() => {
+    const n = s.current, o = {};
+    for (const u in a)
+      o[u] = a[u].value;
     let l = !1;
-    for (const h of e) {
-      const { key: m, useShallowArrayEqual: c } = h, f = o[m], d = n[m];
-      if (c) {
-        if (!oe(d, f)) {
+    for (const u of e) {
+      const { key: v, useShallowArrayEqual: h } = u, f = o[v], c = n[v];
+      if (h) {
+        if (!he(c, f)) {
           l = !0;
           break;
         }
-      } else if (d !== f) {
+      } else if (c !== f) {
         l = !0;
         break;
       }
     }
     if (!l && n.__snapshot)
       return n.__snapshot;
-    for (const h in s)
-      n[h] = o[h];
+    for (const u in a)
+      n[u] = o[u];
     return n.__snapshot = t(o), n.__snapshot;
-  }, [s, t]);
-  return U.useSyncExternalStore(i, a, a);
+  }, [a, t]);
+  return R.useSyncExternalStore(i, r, r);
 }
-function le(s) {
+function de(a) {
   const e = {
-    value: s.value,
-    disabled: s.disabled,
-    errors: s.errors,
-    pending: s.pending,
-    valid: s.valid,
-    invalid: s.invalid,
-    touched: s.touched,
-    shouldShowError: s.shouldShowError,
-    componentProps: s.componentProps
+    value: a.value,
+    disabled: a.disabled,
+    errors: a.errors,
+    pending: a.pending,
+    valid: a.valid,
+    invalid: a.invalid,
+    touched: a.touched,
+    shouldShowError: a.shouldShowError,
+    componentProps: a.componentProps
   }, t = [
     { key: "value" },
     { key: "disabled" },
@@ -2835,7 +3110,7 @@ function le(s) {
     { key: "touched" },
     { key: "shouldShowError" },
     { key: "componentProps" }
-  ], r = b(
+  ], s = b(
     (i) => ({
       value: i.value,
       pending: i.pending,
@@ -2849,18 +3124,18 @@ function le(s) {
     }),
     []
   );
-  return $(e, t, r);
+  return q(e, t, s);
 }
-function ue(s) {
+function ce(a) {
   const e = {
-    value: s.value,
-    length: s.length,
-    errors: s.errors,
-    pending: s.pending,
-    valid: s.valid,
-    invalid: s.invalid,
-    touched: s.touched,
-    dirty: s.dirty
+    value: a.value,
+    length: a.length,
+    errors: a.errors,
+    pending: a.pending,
+    valid: a.valid,
+    invalid: a.invalid,
+    touched: a.touched,
+    dirty: a.dirty
   }, t = [
     { key: "value" },
     { key: "length" },
@@ -2870,7 +3145,7 @@ function ue(s) {
     { key: "invalid" },
     { key: "touched" },
     { key: "dirty" }
-  ], r = b(
+  ], s = b(
     (i) => ({
       value: i.value,
       length: i.length,
@@ -2883,11 +3158,11 @@ function ue(s) {
     }),
     []
   );
-  return $(e, t, r);
+  return q(e, t, s);
 }
-function ge(s) {
-  const e = s && "length" in s && "map" in s;
-  return s ? e ? ue(s) : le(s) : {
+function Ee(a) {
+  const e = a && "length" in a && "map" in a;
+  return a ? e ? ce(a) : de(a) : {
     value: [],
     length: 0,
     pending: !1,
@@ -2898,57 +3173,99 @@ function ge(s) {
     dirty: !1
   };
 }
-function _e(s) {
-  const e = G({ value: s.value.value }), t = b(
+function _e(a) {
+  const e = P({ value: a.value.value }), t = b(
     (i) => {
-      let a = !0;
-      return E(() => {
-        if (s.value.value, a) {
-          a = !1;
+      let r = !0;
+      return m(() => {
+        if (a.value.value, r) {
+          r = !1;
           return;
         }
         i();
       });
     },
-    [s]
-  ), r = b(() => {
-    const i = s.value.value;
+    [a]
+  ), s = b(() => {
+    const i = a.value.value;
     return e.current.value === i ? e.current.value : (e.current.value = i, i);
-  }, [s]);
-  return U.useSyncExternalStore(t, r, r);
+  }, [a]);
+  return R.useSyncExternalStore(t, s, s);
+}
+function Se(a) {
+  const e = P({ length: a.length.value }), t = b(
+    (i) => {
+      let r = !0;
+      return m(() => {
+        if (a.length.value, r) {
+          r = !1;
+          return;
+        }
+        i();
+      });
+    },
+    [a]
+  ), s = b(() => {
+    const i = a.length.value;
+    return e.current.length === i ? e.current.length : (e.current.length = i, i);
+  }, [a]);
+  return R.useSyncExternalStore(t, s, s);
+}
+function Ve(a, e, t) {
+  const s = b(
+    (r) => {
+      const n = e, o = [];
+      for (const l of Object.keys(n)) {
+        const u = n[l];
+        if (u && typeof u == "object" && u.value && typeof u.value.subscribe == "function") {
+          const v = u.value.subscribe(r);
+          o.push(v);
+        }
+      }
+      return () => {
+        o.forEach((l) => l());
+      };
+    },
+    [e]
+  ), i = b(() => a ? a(e, t) : !1, [a, e, t]);
+  return Q(s, i, i);
 }
 export {
-  N as ArrayNode,
-  pe as Debouncer,
+  ke as AbstractRegistry,
+  L as ArrayNode,
   V as ErrorStrategy,
-  Q as FieldNode,
-  Z as FieldPathNavigator,
-  O as FormErrorHandler,
-  F as FormNode,
-  w as GroupNode,
-  ee as NodeFactory,
-  Fe as RegistryStack,
-  me as Resources,
-  C as SubscriptionManager,
-  Se as behaviors,
-  D as createFieldPath,
-  ye as createForm,
-  Ce as extractKey,
-  Re as extractPath,
-  Te as getCurrentBehaviorRegistry,
-  De as getCurrentValidationRegistry,
-  Ae as getNodeType,
-  T as isArrayNode,
-  R as isFieldNode,
-  Ve as isFormNode,
-  ke as isGroupNode,
-  ie as partialResource,
-  re as preloadResource,
-  te as staticResource,
-  Ne as toFieldPath,
-  S as uniqueId,
-  ge as useFormControl,
+  ee as FieldNode,
+  se as FieldPathNavigator,
+  S as FormErrorHandler,
+  C as FormNode,
+  be as FormObserver,
+  Z as FormStatusMachine,
+  ae as FormSubmitter,
+  k as GroupNode,
+  ne as NodeFactory,
+  xe as RegistryStack,
+  D as SubscriptionManager,
+  $e as behaviors,
+  I as createFieldPath,
+  ge as createForm,
+  Ie as extractKey,
+  Le as extractPath,
+  Fe as getCurrentBehaviorRegistry,
+  Te as getCurrentValidationRegistry,
+  Pe as getNodeType,
+  N as isArrayNode,
+  M as isFieldNode,
+  Ce as isFormNode,
+  De as isGroupNode,
+  We as runOutsideEffect,
+  qe as safeCallback,
+  je as safeDebouncedCallback,
+  Be as toFieldPath,
+  A as uniqueId,
+  Se as useArrayLength,
+  Ee as useFormControl,
   _e as useFormControlValue,
-  xe as validateForm,
-  Pe as validators
+  Ve as useHiddenCondition,
+  Re as validateForm,
+  Me as validators
 };