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

package/dist/index.js

@@ -1,12 +1,14 @@
-import { d as y, w as u, E, r as U } from "./behaviors-2HSqHPb4.js";
-import { i as Ee } from "./behaviors-2HSqHPb4.js";
-import { i as C, a as D, A as j, V as q, T as K } from "./validators-gXoHPdqM.js";
-import { g as Se, c as we, d as Ae, v as Ve, b as ke } from "./validators-gXoHPdqM.js";
-import { V as H, B as W, c as R } from "./registry-helpers-BRxAr6nG.js";
-import { R as Oe, a as Fe, e as Pe, b as Ce, g as De, t as Re } from "./registry-helpers-BRxAr6nG.js";
-import { v4 as z } from "uuid";
-import B, { useRef as L, 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((i) => {
-      if (e.code !== void 0 && !(Array.isArray(e.code) ? e.code : [e.code]).includes(i.code) || e.message !== void 0 && !i.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 (!i.params)
+        if (!s.params)
           return !1;
-        for (const [r, s] of Object.entries(e.params))
-          if (i.params[r] !== s)
+        for (const [i, r] of Object.entries(e.params))
+          if (s.params[i] !== r)
             return !1;
       }
-      return !(e.predicate !== void 0 && !e.predicate(i));
+      return !(e.predicate !== void 0 && !e.predicate(s));
     }) : t;
   }
   // ============================================================================
@@ -283,7 +285,7 @@ class F {
   onEnable() {
   }
 }
-class P {
+class D {
   /**
    * Хранилище подписок
    * Ключ: уникальный идентификатор подписки
@@ -451,157 +453,196 @@ class P {
     this.clear();
   }
 }
-var A = /* @__PURE__ */ ((a) => (a.THROW = "throw", a.LOG = "log", a.CONVERT = "convert", a))(A || {});
-class O {
+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}`;
+}
+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, i = "throw") {
-    const r = this.extractMessage(e);
-    switch (i) {
-      case "throw":
-        throw e;
-      case "log":
-        return;
-      case "convert":
-        return {
-          code: "validator_error",
-          message: r,
-          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, i) {
-    return {
-      code: e,
-      message: t,
-      params: i ? { field: i } : 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 J 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;
@@ -617,23 +658,26 @@ class J 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 P();
+  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)
     );
   }
   // ============================================================================
@@ -645,12 +689,12 @@ class J extends F {
   setValue(e, t) {
     if (this._value.value = e, this._dirty.value = !0, t?.emitEvent === !1)
       return;
-    const i = this.validators.length > 0 || this.asyncValidators.length > 0, r = 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;
     }
-    r && i && this.validate();
+    i && s && this.validate();
   }
   patchValue(e) {
     this.setValue(e);
@@ -679,7 +723,7 @@ class J 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)
@@ -709,13 +753,25 @@ class J 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
@@ -729,86 +785,102 @@ class J extends F {
    */
   async validate(e) {
     const t = e?.debounce ?? this.debounceMs;
-    return t > 0 && this.asyncValidators.length > 0 ? new Promise((i) => {
-      const r = this.currentValidationId;
-      this.validateDebounceResolve && this.validateDebounceResolve(!1), this.validateDebounceTimer && clearTimeout(this.validateDebounceTimer), this.validateDebounceResolve = i, this.validateDebounceTimer = setTimeout(async () => {
-        if (this.validateDebounceResolve = void 0, r !== this.currentValidationId) {
+    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 s = await this.validateImmediate();
-        i(s);
-      }, 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 i = [];
-    for (const s of this.validators) {
-      const n = s(this._value.value);
-      n && i.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 (i.length > 0)
-      return this._errors.value = i, 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 s = 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",
-                A.CONVERT
+                V.CONVERT
               );
             }
           })
         );
-        if (t.aborted)
+        if (s.aborted)
           return !1;
-        this._pending.value = !1;
-        const n = s.filter(Boolean);
-        if (n.length > 0)
-          return this._errors.value = n, this._status.value = "invalid", !1;
-      } catch (s) {
-        if (s instanceof DOMException && s.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 s;
+        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)
@@ -824,18 +896,18 @@ class J 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)
@@ -900,25 +972,35 @@ class J 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 t = new AbortController(), s = m(() => {
       const r = this.value.value;
-      e(r);
-    }), i = `watch-${Date.now()}-${Math.random()}`;
-    return this.disposers.add(i, t);
+      e(r, t.signal);
+    }), i = A(w.Watch);
+    return this.disposers.add(i, () => {
+      t.abort(), s();
+    });
   }
   /**
    * Вычисляемое значение из других полей
@@ -943,11 +1025,11 @@ class J extends F {
    * ```
    */
   computeFrom(e, t) {
-    const i = E(() => {
-      const s = e.map((o) => o.value), n = t(...s);
+    const s = m(() => {
+      const r = e.map((o) => o.value), n = t(...r);
       this.setValue(n, { emitEvent: !1 });
-    }), r = `computeFrom-${Date.now()}-${Math.random()}`;
-    return this.disposers.add(r, i);
+    }), i = A(w.ComputeFrom);
+    return this.disposers.add(i, s);
   }
   /**
    * Очистить все ресурсы и таймеры
@@ -956,9 +1038,9 @@ class J extends F {
    * @remarks
    * Освобождает все ресурсы:
    * - Отписывает все subscriptions через SubscriptionManager
-   * - Очищает debounce таймер
-   * - Resolve'ит висячий debounce промис (предотвращает утечку памяти)
-   * - Отменяет текущую async валидацию через AbortController
+   * - Отменяет pending/running валидации через cancelPendingValidation()
+   *
+   * Использует try-finally для гарантированного cleanup даже при ошибках.
    *
    * @example
    * ```typescript
@@ -970,10 +1052,14 @@ class J 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 Y {
+class te {
   form;
   constructor(e) {
     this.form = e;
@@ -989,8 +1075,8 @@ class Y {
    * @param validators Зарегистрированные валидаторы
    */
   async apply(e) {
-    const { validatorsByField: t, treeValidators: i } = this.groupValidators(e);
-    await this.applyFieldValidators(t), this.applyTreeValidators(i);
+    const { validatorsByField: t, treeValidators: s } = this.groupValidators(e);
+    await this.applyFieldValidators(t), this.applyTreeValidators(s);
   }
   /**
    * Группировка валидаторов по типам
@@ -1003,15 +1089,15 @@ class Y {
    * @returns Сгруппированные валидаторы
    */
   groupValidators(e) {
-    const t = /* @__PURE__ */ new Map(), i = [];
-    for (const r of e)
-      if (r.type === "tree")
-        i.push(r);
+    const t = /* @__PURE__ */ new Map(), s = [];
+    for (const i of e)
+      if (i.type === "tree")
+        s.push(i);
       else {
-        const s = t.get(r.fieldPath) || [];
-        s.push(r), t.set(r.fieldPath, s);
+        const r = t.get(i.fieldPath) || [];
+        r.push(i), t.set(i.fieldPath, r);
       }
-    return { validatorsByField: t, treeValidators: i };
+    return { validatorsByField: t, treeValidators: s };
   }
   /**
    * Применение field валидаторов к полям
@@ -1025,37 +1111,44 @@ class Y {
    * @param validatorsByField Валидаторы, сгруппированные по полям
    */
   async applyFieldValidators(e) {
-    for (const [t, i] of e) {
-      const r = this.form.getFieldByPath(t);
-      if (!r) {
+    for (const [t, s] of e) {
+      const i = this.form.getFieldByPath(t);
+      if (!i) {
         console.warn(`Field ${t} not found in GroupNode`);
         continue;
       }
-      if (!C(r) && !D(r)) {
+      if (!M(i) && !N(i)) {
         process.env.NODE_ENV !== "production" && console.warn(`Validation can only run on FieldNode or ArrayNode, skipping ${t}`);
         continue;
       }
-      const s = [];
+      const r = [];
       let n;
-      if (D(r)) {
-        const o = r.getValue();
-        n = new j(this.form, t, o);
+      if (N(i)) {
+        const o = i.getValue();
+        n = new z(this.form, t, o);
       } else
-        n = new q(this.form, t, r);
-      for (const o of i)
+        n = new J(this.form, t, i);
+      for (const o of s)
         if (!(o.condition && !this.checkCondition(o.condition)))
           try {
             let l = null;
-            const d = n.value(), m = o.validator;
-            o.type === "sync" ? l = m(d, n) : o.type === "async" && (l = await m(d, n)), l && s.push(l);
+            const u = n.value();
+            if (o.type === "sync") {
+              const v = o.validator;
+              l = v(u, n);
+            } else if (o.type === "async") {
+              const v = o.validator;
+              l = await v(u, n);
+            }
+            l && r.push(l);
           } catch (l) {
-            O.handle(
+            S.handle(
               l,
               `ValidationApplicator: validator for ${t}`,
-              A.LOG
+              V.LOG
             );
           }
-      s.length > 0 ? r.setErrors(s) : r.clearErrors();
+      r.length > 0 ? i.setErrors(r) : i.clearErrors();
     }
   }
   /**
@@ -1068,24 +1161,24 @@ class Y {
    */
   applyTreeValidators(e) {
     for (const t of e) {
-      const i = new K(this.form);
+      const s = new Y(this.form);
       if (!(t.condition && !this.checkCondition(t.condition)))
         try {
           if (t.type !== "tree")
             continue;
-          const r = t.validator(i);
+          const i = t.validator, r = i(s);
           if (r && t.options && "targetField" in t.options) {
-            const s = t.options.targetField;
-            if (s) {
-              const n = this.form.getFieldByPath(String(s));
-              if (n && C(n)) {
-                const o = n.errors.value;
-                n.setErrors([...o, r]);
+            const n = t.options.targetField;
+            if (n) {
+              const o = this.form.getFieldByPath(String(n));
+              if (o && M(o)) {
+                const l = o.errors.value;
+                o.setErrors([...l, r]);
               }
             }
           }
-        } catch (r) {
-          O.handle(r, "ValidationApplicator: tree validator", A.LOG);
+        } catch (i) {
+          S.handle(i, "ValidationApplicator: tree validator", V.LOG);
         }
     }
   }
@@ -1102,11 +1195,11 @@ class Y {
     const t = this.form.getFieldByPath(e.fieldPath);
     if (!t)
       return !1;
-    const i = t.value.value;
-    return e.conditionFn(i);
+    const s = t.value.value;
+    return e.conditionFn(s);
   }
 }
-class Q {
+class se {
   /**
    * Парсит путь в массив сегментов
    *
@@ -1133,22 +1226,22 @@ class Q {
    */
   parsePath(e) {
     const t = [];
-    let i = "", r = !1;
-    for (let s = 0; s < e.length; s++) {
-      const n = e[s];
-      n === "[" ? (r = !0, i += n) : n === "]" ? (r = !1, i += n) : n === "." && !r ? i && (this.addSegment(t, i), i = "") : i += 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 i && this.addSegment(t, i), t;
+    return s && this.addSegment(t, s), t;
   }
   /**
    * Добавляет сегмент в массив, обрабатывая массивы
    * @private
    */
   addSegment(e, t) {
-    const i = t.match(/^(.+)\[(\d+)\]$/);
-    i ? e.push({
-      key: i[1],
-      index: parseInt(i[2], 10)
+    const s = t.match(/^(.+)\[(\d+)\]$/);
+    s ? e.push({
+      key: s[1],
+      index: parseInt(s[2], 10)
     }) : e.push({ key: t });
   }
   /**
@@ -1183,16 +1276,16 @@ class Q {
    * ```
    */
   getValueByPath(e, t) {
-    const i = this.parsePath(t);
-    let r = e;
-    for (const s of i) {
-      if (r == null) return;
-      if (r = r[s.key], s.index !== void 0) {
-        if (!Array.isArray(r)) return;
-        r = r[s.index];
+    const s = this.parsePath(t);
+    let i = e;
+    for (const r of s) {
+      if (i == null) return;
+      if (i = i[r.key], r.index !== void 0) {
+        if (!Array.isArray(i)) return;
+        i = i[r.index];
       }
     }
-    return r;
+    return i;
   }
   /**
    * Устанавливает значение по пути в объекте (мутирует объект)
@@ -1221,31 +1314,31 @@ class Q {
    * // obj3.items[0].title === 'New'
    * ```
    */
-  setValueByPath(e, t, i) {
-    const r = this.parsePath(t);
-    if (r.length === 0)
+  setValueByPath(e, t, s) {
+    const i = this.parsePath(t);
+    if (i.length === 0)
       throw new Error("Cannot set value: empty path");
-    let s = e;
-    for (let o = 0; o < r.length - 1; o++) {
-      const l = r[o];
-      let d = s[l.key];
+    let r = e;
+    for (let o = 0; o < i.length - 1; o++) {
+      const l = i[o];
+      let u = r[l.key];
       if (l.index !== void 0) {
-        if (!Array.isArray(d))
-          throw new Error(`Expected array at path segment: ${l.key}, but got ${typeof d}`);
-        s = d[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
-        d == null && (s[l.key] = {}, d = s[l.key]), s = d;
+        u == null && (r[l.key] = {}, u = r[l.key]), r = u;
     }
-    const n = r[r.length - 1];
+    const n = i[i.length - 1];
     if (n.index !== void 0) {
-      const o = s[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] = i;
+      o[n.index] = s;
     } else
-      s[n.key] = i;
+      r[n.key] = s;
   }
   /**
    * Получить значение из FormNode по пути
@@ -1282,9 +1375,9 @@ class Q {
    * ```
    */
   getFormNodeValue(e, t) {
-    const i = this.getNodeByPath(e, t);
-    if (i != null)
-      return this.isFormNode(i) ? i.value.value : i;
+    const s = this.getNodeByPath(e, t);
+    if (s != null)
+      return this.isFormNode(s) ? s.value.value : s;
   }
   /**
    * Type guard для проверки, является ли объект FormNode
@@ -1342,40 +1435,177 @@ class Q {
    * ```
    */
   getNodeByPath(e, t) {
-    const i = this.parsePath(t);
-    let r = e;
-    for (const s of i) {
-      if (r == null) return null;
-      const n = r;
+    const s = this.parsePath(t);
+    let i = e;
+    for (const r of s) {
+      if (i == null) return null;
+      const n = i;
       if (n.fields && n.fields instanceof Map) {
-        if (r = n.fields.get(s.key), s.index === void 0) {
-          if (r == null) return null;
+        if (i = n.fields.get(r.key), r.index === void 0) {
+          if (i == null) return null;
           continue;
         }
-      } else if (s.index !== void 0 && n.items) {
+      } else if (r.index !== void 0 && n.items) {
         const o = n.items.value || n.items;
-        if (!Array.isArray(o) || (r = o[s.index], r == null)) return null;
+        if (!Array.isArray(o) || (i = o[r.index], i == null)) return null;
         continue;
-      } else if (s.index === void 0) {
-        if (r = n[s.key], r == null) return null;
+      } else if (r.index === void 0) {
+        if (i = n[r.key], i == null) return null;
         continue;
       }
-      if (r && s.index !== void 0 && r.items) {
-        const o = r.items.value || r.items;
+      if (i && r.index !== void 0 && i.items) {
+        const o = i.items.value || i.items;
         if (!Array.isArray(o)) return null;
-        r = o[s.index];
-      } else if (r && s.index !== void 0 && !r.items)
+        i = o[r.index];
+      } else if (i && r.index !== void 0 && !i.items)
         return null;
-      if (r == null) return null;
+      if (i == null) return null;
+    }
+    return i;
+  }
+}
+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;
     }
-    return r;
+  }
+  /**
+   * Проверить, идет ли отправка формы
+   */
+  isSubmitting() {
+    return this._submitting.value;
   }
 }
-class S extends F {
+class k extends C {
   // ============================================================================
   // Приватные поля
   // ============================================================================
-  id = z();
+  id = crypto.randomUUID();
   /**
    * Коллекция полей формы (упрощённый Map вместо FieldRegistry)
    */
@@ -1384,7 +1614,7 @@ class S extends F {
   /**
    * Менеджер подписок для централизованного cleanup
    */
-  disposers = new P();
+  disposers = new D();
   /**
    * Ссылка на Proxy-инстанс для использования в BehaviorContext
    */
@@ -1392,32 +1622,35 @@ class S extends F {
   /**
    * Навигатор для работы с путями к полям
    */
-  pathNavigator = new Q();
+  pathNavigator = new se();
   /**
    * Фабрика для создания узлов формы
    */
-  nodeFactory = new X();
+  nodeFactory = new ne();
   /**
    * Реестр валидаторов для этой формы
+   * Может быть инжектирован через config._validationRegistry для тестирования
    */
-  validationRegistry = new H();
+  validationRegistry;
   /**
    * Реестр behaviors для этой формы
+   * Может быть инжектирован через config._behaviorRegistry для тестирования
    */
-  behaviorRegistry = new W();
+  behaviorRegistry;
   /**
    * Аппликатор для применения валидаторов к форме
    */
-  validationApplicator = new Y(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
   // ============================================================================
@@ -1431,76 +1664,56 @@ class S extends F {
   status;
   submitting;
   constructor(e) {
-    super();
-    const t = "form" in e, i = t ? e.form : e, r = t ? e.behavior : void 0, s = t ? e.validation : void 0;
-    for (const [o, l] of Object.entries(i)) {
-      const d = this.createNode(l);
-      this._fields.set(o, d);
+    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 o = {};
-      return this._fields.forEach((l, d) => {
-        o[d] = l.value.value;
-      }), o;
-    }), this.valid = u(() => this._formErrors.value.length > 0 ? !1 : Array.from(this._fields.values()).every((o) => o.valid.value)), this.invalid = u(() => !this.valid.value), this.pending = u(
-      () => Array.from(this._fields.values()).some((o) => o.pending.value)
-    ), this.touched = u(
-      () => Array.from(this._fields.values()).some((o) => o.touched.value)
-    ), this.dirty = u(
-      () => Array.from(this._fields.values()).some((o) => o.dirty.value)
-    ), this.errors = u(() => {
-      const o = [...this._formErrors.value];
-      return this._fields.forEach((l) => {
-        o.push(...l.errors.value);
-      }), o;
-    }), this.status = u(() => this._disabled.value ? "disabled" : this.pending.value ? "pending" : this.invalid.value ? "invalid" : "valid"), this.submitting = u(() => this._submitting.value);
-    const n = this.buildProxy();
-    return this._proxyInstance = n, r && this.applyBehaviorSchema(r), s && this.applyValidationSchema(s), n;
-  }
-  // ============================================================================
-  // Приватный метод для создания 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, i) => {
-        if (i in t)
-          return t[i];
-        if (typeof i == "string" && e._fields.has(i))
-          return e._fields.get(i);
-      },
-      set: (t, i, r) => typeof i == "string" && e._fields.has(i) ? !1 : (t[i] = r, !0),
-      has: (t, i) => typeof i == "string" && e._fields.has(i) ? !0 : i in t,
-      ownKeys: (t) => {
-        const i = Reflect.ownKeys(t), r = Array.from(e._fields.keys());
-        return [.../* @__PURE__ */ new Set([...i, ...r])];
-      },
-      getOwnPropertyDescriptor: (t, i) => typeof i == "string" && e._fields.has(i) ? { enumerable: !0, configurable: !0 } : Reflect.getOwnPropertyDescriptor(t, i)
-    });
+    return re(this, this._fields);
   }
   // ============================================================================
   // Реализация абстрактных методов FormNode
   // ============================================================================
   getValue() {
     const e = {};
-    return this._fields.forEach((t, i) => {
-      e[i] = t.getValue();
+    return this._fields.forEach((t, s) => {
+      e[s] = t.getValue();
     }), e;
   }
   setValue(e, t) {
-    for (const [i, r] of Object.entries(e)) {
-      const s = this._fields.get(i);
-      s && s.setValue(r, t);
+    for (const [s, i] of Object.entries(e)) {
+      const r = this._fields.get(s);
+      r && r.setValue(i, t);
     }
   }
   patchValue(e) {
-    U(() => {
-      for (const [t, i] of Object.entries(e)) {
-        const r = this._fields.get(t);
-        r && i !== void 0 && r.setValue(i);
+    j(() => {
+      for (const [t, s] of Object.entries(e)) {
+        const i = this._fields.get(t);
+        i && s !== void 0 && i.setValue(s, { emitEvent: !1 });
       }
     });
   }
@@ -1522,9 +1735,9 @@ class S extends F {
    * ```
    */
   reset(e) {
-    this._fields.forEach((t, i) => {
-      const r = e?.[i];
-      t.reset(r);
+    this._fields.forEach((t, s) => {
+      const i = e?.[s];
+      t.reset(i);
     });
   }
   /**
@@ -1538,7 +1751,9 @@ class S 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
@@ -1591,7 +1806,7 @@ class S extends F {
    * ```
    */
   getProxy() {
-    return this._proxyInstance || this;
+    return this._proxyInstance || (this._proxyInstance = this.buildProxy()), this._proxyInstance;
   }
   /**
    * Получить все поля формы как итератор
@@ -1619,16 +1834,23 @@ class S 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 к форме
@@ -1639,10 +1861,10 @@ class S extends F {
   applyValidationSchema(e) {
     this.validationRegistry.beginRegistration();
     try {
-      const t = R();
+      const t = I();
       e(t);
-      const i = this.getProxy();
-      this.validationRegistry.endRegistration(i);
+      const s = this.getProxy();
+      this.validationRegistry.endRegistration(s);
     } catch (t) {
       throw console.error("Error applying validation schema:", t), t;
     }
@@ -1654,7 +1876,7 @@ class S extends F {
   applyBehaviorSchema(e) {
     this.behaviorRegistry.beginRegistration();
     try {
-      const t = R();
+      const t = I();
       return e(t), this.behaviorRegistry.endRegistration(this.getProxy()).cleanup;
     } catch (t) {
       throw console.error("Error applying behavior schema:", t), t;
@@ -1695,18 +1917,18 @@ class S extends F {
     const t = this.pathNavigator.parsePath(e);
     if (t.length === 0)
       return;
-    let i = this;
-    for (const r of t) {
-      if (!(i instanceof S) || (i = i.getField(r.key), !i)) return;
-      if (r.index !== void 0)
-        if ("at" in i && "length" in i && typeof i.at == "function") {
-          const s = i.at(r.index);
-          if (!s) return;
-          i = s;
+    let s = this;
+    for (const i of t) {
+      if (!(s instanceof k) || (s = s.getField(i.key), !s)) return;
+      if (i.index !== void 0)
+        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 i;
+    return s;
   }
   /**
    * Применить contextual валидаторы к полям
@@ -1750,15 +1972,16 @@ class S extends F {
   /**
    * Связывает два поля: при изменении source автоматически обновляется target
    */
-  linkFields(e, t, i) {
-    const r = this._fields.get(e), s = this._fields.get(t);
-    if (!r || !s)
-      return () => {
-      };
-    const n = E(() => {
-      const l = r.value.value, d = i ? i(l) : l;
-      s.setValue(d, { emitEvent: !1 });
-    }), o = `linkFields-${Date.now()}-${Math.random()}`;
+  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);
   }
   /**
@@ -1789,15 +2012,14 @@ class S extends F {
    * ```
    */
   watchField(e, t) {
-    const i = this.getFieldByPath(e);
-    if (!i)
-      return () => {
-      };
-    const r = E(() => {
-      const n = i.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);
-    }), s = `watchField-${Date.now()}-${Math.random()}`;
-    return this.disposers.add(s, r);
+    }), r = A(w.WatchField);
+    return this.disposers.add(r, i);
   }
   /**
    * Hook: вызывается после disable()
@@ -1820,7 +2042,7 @@ class S extends F {
     });
   }
 }
-class T extends F {
+class L extends C {
   // ============================================================================
   // Приватные поля
   // ============================================================================
@@ -1831,7 +2053,9 @@ class T extends F {
    * Менеджер подписок для централизованного cleanup
    * Использует SubscriptionManager вместо массива для управления подписками
    */
-  disposers = new P();
+  disposers = new D();
+  /** Array-level validation errors (e.g., "минимум 1 элемент") */
+  _arrayErrors = g([]);
   // ============================================================================
   // Приватные поля для сохранения схем
   // ============================================================================
@@ -1853,15 +2077,15 @@ class T extends F {
   // Конструктор
   // ============================================================================
   constructor(e, t = []) {
-    super(), this.itemSchema = e, this.initialItems = t, this.items = y([]);
+    super(), this.itemSchema = e, this.initialItems = t, this.items = g([]);
     for (const i of t)
       this.push(i);
-    this.length = u(() => this.items.value.length), this.value = u(() => this.items.value.map((i) => i.value.value)), this.valid = u(() => this.items.value.every((i) => i.valid.value)), this.invalid = u(() => !this.valid.value), this.pending = u(() => this.items.value.some((i) => i.pending.value)), this.touched = u(() => this.items.value.some((i) => i.touched.value)), this.dirty = u(() => this.items.value.some((i) => i.dirty.value)), this.errors = u(() => {
-      const i = [];
-      return this.items.value.forEach((r) => {
-        i.push(...r.errors.value);
-      }), i;
-    }), this.status = u(() => this.pending.value ? "pending" : this.invalid.value ? "invalid" : "valid");
+    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 операции
@@ -1877,9 +2101,23 @@ class T extends F {
   /**
    * Удалить элемент по индексу
    * @param index - Индекс элемента для удаления
+   *
+   * @remarks
+   * Вызывает dispose() на удаляемом элементе для очистки подписок
    */
   removeAt(e) {
-    e < 0 || e >= this.items.value.length || (this.items.value = this.items.value.filter((t, i) => i !== 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();
   }
   /**
    * Вставить элемент в массив
@@ -1887,24 +2125,40 @@ class T 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 i = this.createItem(t), r = [...this.items.value];
-    r.splice(e, 0, i), this.items.value = r;
+    }
+    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();
+    });
   }
   /**
    * Получить элемент по индексу
    * @param index - Индекс элемента
-   * @returns Типизированный GroupNode или undefined если индекс вне границ
+   * @returns Типизированный GroupNode proxy или undefined если индекс вне границ
    */
   at(e) {
-    return this.items.value[e];
+    const t = this.items.value[e];
+    if (t)
+      return t.getProxy();
   }
   // ============================================================================
   // Реализация абстрактных методов
@@ -1913,12 +2167,13 @@ class T extends F {
     return this.items.value.map((e) => e.getValue());
   }
   setValue(e, t) {
-    this.clear(), e.forEach((i) => this.push(i)), 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, i) => {
-      this.items.value[i] && t !== void 0 && this.items.value[i].patchValue(t);
+    e.forEach((t, s) => {
+      this.items.value[s] && t !== void 0 && this.items.value[s].patchValue(t);
     });
   }
   /**
@@ -1939,7 +2194,7 @@ class T extends F {
    * ```
    */
   reset(e) {
-    this.clear(), e && e.forEach((t) => this.push(t));
+    this._arrayErrors.value = [], this.clear(), e && e.forEach((t) => this.push(t));
   }
   /**
    * Сбросить массив к исходным значениям (initialItems)
@@ -1970,15 +2225,38 @@ class T extends F {
    * ```
    */
   resetToInitial() {
-    this.clear(), this.initialItems.forEach((e) => this.push(e));
+    this._arrayErrors.value = [], this.clear(), this.initialItems.forEach((e) => this.push(e));
   }
   async validate() {
     return (await Promise.all(this.items.value.map((t) => t.validate()))).every(Boolean);
   }
+  /**
+   * Установить array-level validation errors
+   *
+   * @param errors - Массив ошибок валидации уровня массива
+   *
+   * @example
+   * ```typescript
+   * arrayNode.setErrors([{
+   *   code: 'minItems',
+   *   message: 'Минимум 1 элемент обязателен',
+   * }]);
+   * ```
+   */
   setErrors(e) {
+    this._arrayErrors.value = e;
   }
+  /**
+   * Очистить все errors (array-level + item-level)
+   *
+   * @example
+   * ```typescript
+   * arrayNode.clearErrors();
+   * console.log(arrayNode.errors.value); // []
+   * ```
+   */
   clearErrors() {
-    this.items.value.forEach((e) => e.clearErrors());
+    this._arrayErrors.value = [], this.items.value.forEach((e) => e.clearErrors());
   }
   // ============================================================================
   // Protected hooks (Template Method pattern)
@@ -2020,20 +2298,24 @@ class T extends F {
   // ============================================================================
   /**
    * Итерировать по элементам массива
-   * @param callback - Функция, вызываемая для каждого элемента с типизированным GroupNode
+   * @param callback - Функция, вызываемая для каждого элемента с типизированным GroupNode proxy
    */
   forEach(e) {
-    this.items.value.forEach((t, i) => {
-      e(t, i);
+    this.items.value.forEach((t, s) => {
+      const i = t.getProxy();
+      e(i, s);
     });
   }
   /**
    * Маппинг элементов массива
-   * @param callback - Функция преобразования с типизированным GroupNode
+   * @param callback - Функция преобразования с типизированным GroupNode proxy
    * @returns Новый массив результатов
    */
   map(e) {
-    return this.items.value.map((t, i) => e(t, i));
+    return this.items.value.map((t, s) => {
+      const i = t.getProxy();
+      return e(i, s);
+    });
   }
   // ============================================================================
   // Private методы
@@ -2044,7 +2326,7 @@ class T extends F {
    */
   createItem(e) {
     if (this.isGroupSchema(this.itemSchema)) {
-      const t = new S(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(
@@ -2131,14 +2413,14 @@ class T extends F {
    * ```
    */
   watchItems(e, t) {
-    const i = E(() => {
-      const s = this.items.value.map((n) => {
-        if (n instanceof S)
+    const s = m(() => {
+      const r = this.items.value.map((n) => {
+        if (n instanceof k)
           return n.getFieldByPath(e)?.value.value;
       });
-      t(s);
-    }), r = `watchItems-${Date.now()}-${Math.random()}`;
-    return this.disposers.add(r, i);
+      t(r);
+    }), i = A(w.WatchItems);
+    return this.disposers.add(i, s);
   }
   /**
    * Подписка на изменение длины массива
@@ -2163,11 +2445,11 @@ class T extends F {
    * ```
    */
   watchLength(e) {
-    const t = E(() => {
-      const r = this.length.value;
-      e(r);
-    }), i = `watchLength-${Date.now()}-${Math.random()}`;
-    return this.disposers.add(i, t);
+    const t = m(() => {
+      const i = this.length.value;
+      e(i);
+    }), s = A(w.WatchLength);
+    return this.disposers.add(s, t);
   }
   /**
    * Очистить все ресурсы узла
@@ -2230,7 +2512,7 @@ class T extends F {
     });
   }
 }
-class X {
+class ne {
   /**
    * Создает узел формы на основе конфигурации
    *
@@ -2280,16 +2562,16 @@ class X {
     if (Array.isArray(e) && e.length >= 1)
       return this.createArrayNodeFromArray(e);
     if (this.isFieldConfig(e))
-      return new J(e);
+      return new ee(e);
     if (this.isArrayConfig(e)) {
       const t = e;
-      return new T(
+      return new L(
         t.schema,
         t.initialItems
       );
     }
     if (this.isGroupConfig(e))
-      return new S(e);
+      return new k(e);
     throw new Error(
       `NodeFactory: Unknown node config. Expected FieldConfig, GroupConfig, or ArrayConfig, but got: ${JSON.stringify(
         e
@@ -2323,11 +2605,11 @@ class X {
    */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   createArrayNodeFromArray(e) {
-    const [t, ...i] = e, r = [];
-    this.isGroupConfig(t) && r.push(this.extractValues(t));
-    for (const s of i)
-      this.isGroupConfig(s) ? r.push(this.extractValues(s)) : r.push(s);
-    return new T(t, r);
+    const [t, ...s] = e, i = [];
+    this.isGroupConfig(t) && i.push(this.extractValues(t));
+    for (const r of s)
+      this.isGroupConfig(r) ? i.push(this.extractValues(r)) : i.push(r);
+    return new L(t, i);
   }
   /**
    * Извлечь значения из схемы (рекурсивно)
@@ -2365,8 +2647,8 @@ class X {
       return e.map((t) => this.extractValues(t));
     if (this.isGroupConfig(e)) {
       const t = {};
-      for (const [i, r] of Object.entries(e))
-        t[i] = this.extractValues(r);
+      for (const [s, i] of Object.entries(e))
+        t[s] = this.extractValues(i);
       return t;
     }
     return e;
@@ -2446,299 +2728,334 @@ class X {
     return e != null && typeof e == "object" && !this.isFieldConfig(e) && !this.isArrayConfig(e);
   }
 }
-class fe {
+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, i) => {
-      if (this.timer && clearTimeout(this.timer), this.delay === 0) {
-        Promise.resolve().then(() => e()).then(t).catch(i);
-        return;
-      }
-      this.timer = setTimeout(async () => {
-        try {
-          const r = await e();
-          t(r);
-        } catch (r) {
-          i(r);
-        }
-      }, 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 ve(a) {
-  return new S(a);
-}
-function Z(a) {
-  return {
-    type: "static",
-    load: async () => ({
-      items: a,
-      totalCount: a.length
-    })
-  };
-}
-function ee(a) {
-  let e = null;
-  return {
-    type: "preload",
-    load: async (t) => {
-      if (!e) {
-        const i = await a(t);
-        e = {
-          items: i,
-          totalCount: i.length
-        };
-      }
-      return e;
-    }
-  };
-}
-function te(a) {
-  return {
-    type: "partial",
-    load: async (e) => {
-      const t = await a(e);
-      return {
-        items: t,
-        totalCount: t.length
-        // Можно расширить для поддержки серверной пагинации
-      };
-    }
-  };
-}
-const pe = {
-  static: Z,
-  preload: ee,
-  partial: te
-};
-var w = { exports: {} }, k = {};
-var M;
-function ie() {
-  if (M) return k;
-  M = 1;
-  var a = B;
-  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, i = a.useState, r = a.useEffect, s = a.useLayoutEffect, n = a.useDebugValue;
-  function o(c, f) {
-    var h = f(), v = i({ inst: { value: h, getSnapshot: f } }), p = v[0].inst, g = v[1];
-    return s(
+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 = h, p.getSnapshot = f, l(p) && g({ inst: p });
+        y.value = c, y.getSnapshot = f, l(y) && E({ inst: y });
       },
-      [c, h, f]
-    ), r(
+      [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(h), h;
+      [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 h = f();
-      return !t(c, h);
+      var c = f();
+      return !t(h, c);
     } catch {
       return !0;
     }
   }
-  function d(c, f) {
+  function u(h, f) {
     return f();
   }
-  var m = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? d : o;
-  return k.useSyncExternalStore = a.useSyncExternalStore !== void 0 ? a.useSyncExternalStore : m, k;
+  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 x = {};
-var I;
-function re() {
-  return I || (I = 1, process.env.NODE_ENV !== "production" && (function() {
-    function a(h, v) {
-      return h === v && (h !== 0 || 1 / h === 1 / v) || h !== h && 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(h, v) {
-      m || r.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();
-        s(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, V = g[1];
+      var _ = E[0].inst, F = E[1];
       return l(
         function() {
-          _.value = p, _.getSnapshot = v, t(_) && V({ inst: _ });
+          _.value = y, _.getSnapshot = p, t(_) && F({ inst: _ });
         },
-        [h, p, v]
+        [c, y, p]
       ), o(
         function() {
-          return t(_) && V({ inst: _ }), h(function() {
-            t(_) && V({ inst: _ });
+          return t(_) && F({ inst: _ }), c(function() {
+            t(_) && F({ inst: _ });
           });
         },
-        [h]
-      ), d(p), p;
+        [c]
+      ), u(y), y;
     }
-    function t(h) {
-      var v = h.getSnapshot;
-      h = h.value;
+    function t(c) {
+      var p = c.getSnapshot;
+      c = c.value;
       try {
-        var p = v();
-        return !s(h, p);
+        var y = p();
+        return !r(c, y);
       } catch {
         return !0;
       }
     }
-    function i(h, 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 r = B, s = typeof Object.is == "function" ? Object.is : a, n = r.useState, o = r.useEffect, l = r.useLayoutEffect, d = r.useDebugValue, m = !1, c = !1, f = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? i : e;
-    x.useSyncExternalStore = r.useSyncExternalStore !== void 0 ? r.useSyncExternalStore : f, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
-  })()), x;
+    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 N;
-function se() {
-  return N || (N = 1, process.env.NODE_ENV === "production" ? w.exports = ie() : w.exports = re()), w.exports;
+var $;
+function ue() {
+  return $ || ($ = 1, process.env.NODE_ENV === "production" ? x.exports = oe() : x.exports = le()), x.exports;
 }
-var $ = se();
-function ae(a, e) {
+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 G(a, e, t) {
-  const i = L(null);
-  if (i.current === null) {
+function q(a, e, t) {
+  const s = P(null);
+  if (s.current === null) {
     const n = {};
     for (const o in a)
       n[o] = a[o].value;
-    i.current = { ...n, __snapshot: null };
+    s.current = { ...n, __snapshot: null };
   }
-  const r = b(
+  const i = b(
     (n) => {
       let o = !0;
-      return E(() => {
-        for (const d in a)
-          a[d].value;
+      return m(() => {
+        for (const u in a)
+          a[u].value;
         if (o) {
           o = !1;
           return;
@@ -2747,32 +3064,32 @@ function G(a, e, t) {
       });
     },
     [a]
-  ), s = b(() => {
-    const n = i.current, o = {};
-    for (const d in a)
-      o[d] = a[d].value;
+  ), r = b(() => {
+    const n = s.current, o = {};
+    for (const u in a)
+      o[u] = a[u].value;
     let l = !1;
-    for (const d of e) {
-      const { key: m, useShallowArrayEqual: c } = d, f = o[m], h = n[m];
-      if (c) {
-        if (!ae(h, 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 (h !== f) {
+      } else if (c !== f) {
         l = !0;
         break;
       }
     }
     if (!l && n.__snapshot)
       return n.__snapshot;
-    for (const d in a)
-      n[d] = o[d];
+    for (const u in a)
+      n[u] = o[u];
     return n.__snapshot = t(o), n.__snapshot;
   }, [a, t]);
-  return $.useSyncExternalStore(r, s, s);
+  return R.useSyncExternalStore(i, r, r);
 }
-function ne(a) {
+function de(a) {
   const e = {
     value: a.value,
     disabled: a.disabled,
@@ -2793,23 +3110,23 @@ function ne(a) {
     { key: "touched" },
     { key: "shouldShowError" },
     { key: "componentProps" }
-  ], i = b(
-    (r) => ({
-      value: r.value,
-      pending: r.pending,
-      disabled: r.disabled,
-      errors: r.errors,
-      valid: r.valid,
-      invalid: r.invalid,
-      touched: r.touched,
-      shouldShowError: r.shouldShowError,
-      componentProps: r.componentProps
+  ], s = b(
+    (i) => ({
+      value: i.value,
+      pending: i.pending,
+      disabled: i.disabled,
+      errors: i.errors,
+      valid: i.valid,
+      invalid: i.invalid,
+      touched: i.touched,
+      shouldShowError: i.shouldShowError,
+      componentProps: i.componentProps
     }),
     []
   );
-  return G(e, t, i);
+  return q(e, t, s);
 }
-function oe(a) {
+function ce(a) {
   const e = {
     value: a.value,
     length: a.length,
@@ -2828,24 +3145,24 @@ function oe(a) {
     { key: "invalid" },
     { key: "touched" },
     { key: "dirty" }
-  ], i = b(
-    (r) => ({
-      value: r.value,
-      length: r.length,
-      pending: r.pending,
-      errors: r.errors,
-      valid: r.valid,
-      invalid: r.invalid,
-      touched: r.touched,
-      dirty: r.dirty
+  ], s = b(
+    (i) => ({
+      value: i.value,
+      length: i.length,
+      pending: i.pending,
+      errors: i.errors,
+      valid: i.valid,
+      invalid: i.invalid,
+      touched: i.touched,
+      dirty: i.dirty
     }),
     []
   );
-  return G(e, t, i);
+  return q(e, t, s);
 }
-function ye(a) {
+function Ee(a) {
   const e = a && "length" in a && "map" in a;
-  return a ? e ? oe(a) : ne(a) : {
+  return a ? e ? ce(a) : de(a) : {
     value: [],
     length: 0,
     pending: !1,
@@ -2856,56 +3173,99 @@ function ye(a) {
     dirty: !1
   };
 }
-function me(a) {
-  const e = L({ value: a.value.value }), t = b(
-    (r) => {
-      let s = !0;
-      return E(() => {
-        if (a.value.value, s) {
-          s = !1;
+function _e(a) {
+  const e = P({ value: a.value.value }), t = b(
+    (i) => {
+      let r = !0;
+      return m(() => {
+        if (a.value.value, r) {
+          r = !1;
+          return;
+        }
+        i();
+      });
+    },
+    [a]
+  ), s = b(() => {
+    const i = a.value.value;
+    return e.current.value === i ? e.current.value : (e.current.value = i, i);
+  }, [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;
         }
-        r();
+        i();
       });
     },
     [a]
-  ), i = b(() => {
-    const r = a.value.value;
-    return e.current.value === r ? e.current.value : (e.current.value = r, r);
+  ), s = b(() => {
+    const i = a.length.value;
+    return e.current.length === i ? e.current.length : (e.current.length = i, i);
   }, [a]);
-  return $.useSyncExternalStore(t, i, i);
+  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 {
-  T as ArrayNode,
-  fe as Debouncer,
-  A as ErrorStrategy,
-  J as FieldNode,
-  Q as FieldPathNavigator,
-  O as FormErrorHandler,
-  F as FormNode,
-  S as GroupNode,
-  X as NodeFactory,
-  Oe as RegistryStack,
-  pe as Resources,
-  P as SubscriptionManager,
-  Ee as behaviors,
-  R as createFieldPath,
-  ve as createForm,
-  Fe as extractKey,
-  Pe as extractPath,
-  Ce as getCurrentBehaviorRegistry,
-  De as getCurrentValidationRegistry,
-  Se as getNodeType,
-  D as isArrayNode,
-  C as isFieldNode,
-  we as isFormNode,
-  Ae as isGroupNode,
-  te as partialResource,
-  ee as preloadResource,
-  Z as staticResource,
-  Re as toFieldPath,
-  ye as useFormControl,
-  me as useFormControlValue,
-  Ve as validateForm,
-  ke as validators
+  ke as AbstractRegistry,
+  L as ArrayNode,
+  V as ErrorStrategy,
+  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,
+  Ve as useHiddenCondition,
+  Re as validateForm,
+  Me as validators
 };