@reformer/core 1.1.0-beta.8 → 2.0.0-beta.10

package/dist/index.js

@@ -1,12 +1,14 @@
-import { d, w as l, E as v, c as S } from "./behaviors-BRaiR-UY.js";
-import { i as oe } from "./behaviors-BRaiR-UY.js";
-import { i as R, V as P, T as M, c as x } from "./validators-DjXtDVoE.js";
-import { g as ue, e as he, b as de, d as ce, v as ve, a as fe } from "./validators-DjXtDVoE.js";
-import { V as C, B as T } from "./registry-helpers-BfCZcMkO.js";
-import { R as ye, a as me, g as ge } from "./registry-helpers-BfCZcMkO.js";
-import { v4 as D } from "uuid";
-import { useRef as V, useCallback as y, useSyncExternalStore as w } from "react";
-class A {
+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 A {
    * Пользователь взаимодействовал с узлом (touched)
    * Protected: наследники могут читать/изменять через методы
    */
-  _touched = d(!1);
+  _touched = g(!1);
   /**
    * Значение узла было изменено (dirty)
    * Protected: наследники могут читать/изменять через методы
    */
-  _dirty = d(!1);
+  _dirty = g(!1);
   /**
    * Текущий статус узла
    * Protected: наследники могут читать/изменять через методы
    */
-  _status = d("valid");
+  _status = g("valid");
   // ============================================================================
   // Публичные computed signals (readonly для внешнего мира)
   // ============================================================================
@@ -32,33 +34,33 @@ class A {
    * Пользователь взаимодействовал с узлом (touched)
    * Computed из _touched для предоставления readonly интерфейса
    */
-  touched = l(() => this._touched.value);
+  touched = d(() => this._touched.value);
   /**
    * Пользователь не взаимодействовал с узлом (untouched)
    */
-  untouched = l(() => !this._touched.value);
+  untouched = d(() => !this._touched.value);
   /**
    * Значение узла было изменено (dirty)
    * Computed из _dirty для предоставления readonly интерфейса
    */
-  dirty = l(() => this._dirty.value);
+  dirty = d(() => this._dirty.value);
   /**
    * Значение узла не было изменено (pristine)
    */
-  pristine = l(() => !this._dirty.value);
+  pristine = d(() => !this._dirty.value);
   /**
    * Текущий статус узла
    * Computed из _status для предоставления readonly интерфейса
    */
-  status = l(() => this._status.value);
+  status = d(() => this._status.value);
   /**
    * Узел отключен (disabled)
    */
-  disabled = l(() => this._status.value === "disabled");
+  disabled = d(() => this._status.value === "disabled");
   /**
    * Узел включен (enabled)
    */
-  enabled = l(() => this._status.value !== "disabled");
+  enabled = d(() => this._status.value !== "disabled");
   /**
    * Получить ошибки валидации с фильтрацией
    *
@@ -100,17 +102,17 @@ class A {
    */
   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 [s, a] of Object.entries(e.params))
-          if (i.params[s] !== a)
+        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 A {
   onEnable() {
   }
 }
-class _ {
+class D {
   /**
    * Хранилище подписок
    * Ключ: уникальный идентификатор подписки
@@ -451,157 +453,196 @@ class _ {
     this.clear();
   }
 }
-var g = /* @__PURE__ */ ((r) => (r.THROW = "throw", r.LOG = "log", r.CONVERT = "convert", r))(g || {});
-class E {
+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 s = this.extractMessage(e);
-    switch (i) {
-      case "throw":
-        throw e;
-      case "log":
-        return;
-      case "convert":
-        return {
-          code: "validator_error",
-          message: s,
-          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
+   * Обработать событие (альтернативный API)
    *
-   * Type guard для ValidationError
-   *
-   * @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 I extends A {
+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,22 +658,26 @@ class I extends A {
   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 _();
+  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 = d(e.value), this._errors = d([]), this._pending = d(!1), this._componentProps = d(e.componentProps || {}), e.disabled && (this._status.value = "disabled"), this.value = l(() => this._value.value), this.valid = l(() => this._status.value === "valid"), this.invalid = l(() => this._status.value === "invalid"), this.pending = l(() => this._pending.value), this.errors = l(() => this._errors.value), this.componentProps = l(() => this._componentProps.value), this.shouldShowError = l(
-      () => 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)
     );
   }
   // ============================================================================
@@ -644,12 +689,12 @@ class I extends A {
   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, s = 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;
     }
-    s && i && this.validate();
+    i && s && this.validate();
   }
   patchValue(e) {
     this.setValue(e);
@@ -678,7 +723,7 @@ class I extends A {
    * ```
    */
   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)
@@ -708,13 +753,25 @@ class I extends A {
   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
@@ -728,69 +785,102 @@ class I extends A {
    */
   async validate(e) {
     const t = e?.debounce ?? this.debounceMs;
-    return t > 0 && this.asyncValidators.length > 0 ? new Promise((i) => {
-      const s = this.currentValidationId;
-      this.validateDebounceResolve && this.validateDebounceResolve(!1), this.validateDebounceTimer && clearTimeout(this.validateDebounceTimer), this.validateDebounceResolve = i, this.validateDebounceTimer = setTimeout(async () => {
-        if (this.validateDebounceResolve = void 0, s !== 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 a = await this.validateImmediate();
-        i(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:
-   * - Проверка validationId после синхронной валидации
-   * - Проверка перед установкой pending
-   * - Проверка после Promise.all
-   * - Проверка перед обработкой async результатов
-   * - Проверка перед очисткой errors
-   */
-  async validateImmediate() {
-    const e = ++this.currentValidationId, t = [];
-    for (const s of this.validators) {
-      const a = s(this._value.value);
-      a && t.push(a);
+   * Защищена от race conditions через AbortController:
+   * - Отменяет предыдущую валидацию при запуске новой (if no controller provided)
+   * - Передаёт AbortSignal в async валидаторы для отмены операций (например, fetch)
+   * - Проверяет signal.aborted в ключевых точках
+   */
+  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 (e !== this.currentValidationId)
+    if (s.aborted)
       return !1;
-    if (t.length > 0)
-      return this._errors.value = t, this._status.value = "invalid", !1;
-    if (this.asyncValidators.length > 0) {
-      if (e !== this.currentValidationId)
+    if (i.length > 0) {
+      this._errors.value = i;
+      const n = i.some((o) => o.severity !== "warning");
+      if (this.statusMachine.setErrors(n), n)
         return !1;
-      this._pending.value = !0, this._status.value = "pending";
-      const s = await Promise.all(
-        this.asyncValidators.map(async (n) => {
-          try {
-            return await n(this._value.value);
-          } catch (o) {
-            return E.handle(
-              o,
-              "FieldNode AsyncValidator",
-              g.CONVERT
-            );
-          }
-        })
-      );
-      if (e !== this.currentValidationId || (this._pending.value = !1, e !== this.currentValidationId))
+    }
+    if (this.asyncValidators.length > 0) {
+      if (s.aborted)
         return !1;
-      const a = s.filter(Boolean);
-      if (a.length > 0)
-        return this._errors.value = a, this._status.value = "invalid", !1;
+      this.statusMachine.startValidation();
+      try {
+        const n = await Promise.all(
+          this.asyncValidators.map(async (l) => {
+            if (s.aborted)
+              throw new DOMException("Validation aborted", "AbortError");
+            try {
+              const u = await l(this._value.value, { signal: s });
+              if (s.aborted)
+                throw new DOMException("Validation aborted", "AbortError");
+              return u;
+            } catch (u) {
+              if (u instanceof DOMException && u.name === "AbortError")
+                throw u;
+              return S.handle(
+                u,
+                "FieldNode AsyncValidator",
+                V.CONVERT
+              );
+            }
+          })
+        );
+        if (s.aborted)
+          return !1;
+        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 n;
+      }
     }
-    return e !== this.currentValidationId ? !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)
@@ -806,18 +896,18 @@ class I extends A {
   /**
    * 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)
@@ -882,25 +972,35 @@ class I extends A {
    * Подписка на изменения значения поля
    * Автоматически отслеживает изменения через @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 = v(() => {
-      const s = this.value.value;
-      e(s);
-    }), i = `watch-${Date.now()}-${Math.random()}`;
-    return this.disposers.add(i, 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();
+    });
   }
   /**
    * Вычисляемое значение из других полей
@@ -925,16 +1025,23 @@ class I extends A {
    * ```
    */
   computeFrom(e, t) {
-    const i = v(() => {
-      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 });
-    }), s = `computeFrom-${Date.now()}-${Math.random()}`;
-    return this.disposers.add(s, i);
+    }), i = A(w.ComputeFrom);
+    return this.disposers.add(i, s);
   }
   /**
    * Очистить все ресурсы и таймеры
    * Должен вызываться при unmount компонента
    *
+   * @remarks
+   * Освобождает все ресурсы:
+   * - Отписывает все subscriptions через SubscriptionManager
+   * - Отменяет pending/running валидации через cancelPendingValidation()
+   *
+   * Использует try-finally для гарантированного cleanup даже при ошибках.
+   *
    * @example
    * ```typescript
    * useEffect(() => {
@@ -945,10 +1052,14 @@ class I extends A {
    * ```
    */
   dispose() {
-    this.disposers.dispose(), this.validateDebounceTimer && (clearTimeout(this.validateDebounceTimer), this.validateDebounceTimer = void 0);
+    try {
+      this.disposers.dispose();
+    } finally {
+      this.cancelPendingValidation();
+    }
   }
 }
-class N {
+class te {
   form;
   constructor(e) {
     this.form = e;
@@ -964,8 +1075,8 @@ class N {
    * @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);
   }
   /**
    * Группировка валидаторов по типам
@@ -978,15 +1089,15 @@ class N {
    * @returns Сгруппированные валидаторы
    */
   groupValidators(e) {
-    const t = /* @__PURE__ */ new Map(), i = [];
-    for (const s of e)
-      if (s.type === "tree")
-        i.push(s);
+    const t = /* @__PURE__ */ new Map(), s = [];
+    for (const i of e)
+      if (i.type === "tree")
+        s.push(i);
       else {
-        const a = t.get(s.fieldPath) || [];
-        a.push(s), t.set(s.fieldPath, a);
+        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 валидаторов к полям
@@ -1000,31 +1111,44 @@ class N {
    * @param validatorsByField Валидаторы, сгруппированные по полям
    */
   async applyFieldValidators(e) {
-    for (const [t, i] of e) {
-      const s = this.form.getFieldByPath(t);
-      if (!s) {
+    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(s)) {
-        process.env.NODE_ENV !== "production" && console.warn(`Validation can only run on FieldNode, skipping ${t}`);
+      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 = [], n = new P(this.form, t, s);
-      for (const o of i)
+      const r = [];
+      let n;
+      if (N(i)) {
+        const o = i.getValue();
+        n = new z(this.form, t, o);
+      } else
+        n = new J(this.form, t, i);
+      for (const o of s)
         if (!(o.condition && !this.checkCondition(o.condition)))
           try {
-            let u = null;
-            const h = n.value(), c = o.validator;
-            o.type === "sync" ? u = c(h, n) : o.type === "async" && (u = await c(h, n)), u && a.push(u);
-          } catch (u) {
-            E.handle(
-              u,
+            let l = null;
+            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) {
+            S.handle(
+              l,
               `ValidationApplicator: validator for ${t}`,
-              g.LOG
+              V.LOG
             );
           }
-      a.length > 0 ? s.setErrors(a) : s.errors.value.length > 0 && !s.errors.value.some((o) => o.code !== "contextual") && s.clearErrors();
+      r.length > 0 ? i.setErrors(r) : i.clearErrors();
     }
   }
   /**
@@ -1037,24 +1161,24 @@ class N {
    */
   applyTreeValidators(e) {
     for (const t of e) {
-      const i = new M(this.form);
+      const s = new Y(this.form);
       if (!(t.condition && !this.checkCondition(t.condition)))
         try {
           if (t.type !== "tree")
             continue;
-          const s = t.validator(i);
-          if (s && t.options && "targetField" in t.options) {
-            const a = t.options.targetField;
-            if (a) {
-              const n = this.form.getFieldByPath(String(a));
-              if (n && R(n)) {
-                const o = n.errors.value;
-                n.setErrors([...o, s]);
+          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 && M(o)) {
+                const l = o.errors.value;
+                o.setErrors([...l, r]);
               }
             }
           }
-        } catch (s) {
-          E.handle(s, "ValidationApplicator: tree validator", g.LOG);
+        } catch (i) {
+          S.handle(i, "ValidationApplicator: tree validator", V.LOG);
         }
     }
   }
@@ -1071,61 +1195,11 @@ class N {
     const t = this.form.getFieldByPath(e.fieldPath);
     if (!t)
       return !1;
-    const i = t.value.value;
-    return e.conditionFn(i);
-  }
-}
-class B {
-  form;
-  behaviorRegistry;
-  constructor(e, t) {
-    this.form = e, this.behaviorRegistry = t;
-  }
-  /**
-   * Применить behavior схему к форме
-   *
-   * Этапы:
-   * 1. Начать регистрацию (beginRegistration)
-   * 2. Выполнить схему (регистрация behaviors)
-   * 3. Завершить регистрацию (endRegistration) - применить behaviors
-   * 4. Вернуть функцию cleanup для отписки
-   *
-   * @param schemaFn Функция-схема behavior
-   * @returns Функция отписки от всех behaviors
-   *
-   * @example
-   * ```typescript
-   * const cleanup = behaviorApplicator.apply((path) => {
-   *   copyFrom(path.residenceAddress, path.registrationAddress, {
-   *     when: (form) => form.sameAsRegistration === true
-   *   });
-   *
-   *   enableWhen(path.propertyValue, (form) => form.loanType === 'mortgage');
-   *
-   *   computeFrom(
-   *     path.initialPayment,
-   *     [path.propertyValue],
-   *     (propertyValue) => propertyValue ? propertyValue * 0.2 : null
-   *   );
-   * });
-   *
-   * // Cleanup при unmount
-   * useEffect(() => cleanup, []);
-   * ```
-   */
-  apply(e) {
-    this.behaviorRegistry.beginRegistration();
-    try {
-      const t = S();
-      e(t);
-      const i = this.form.getProxy();
-      return this.behaviorRegistry.endRegistration(i).cleanup;
-    } catch (t) {
-      throw E.handle(t, "BehaviorApplicator", g.THROW), t;
-    }
+    const s = t.value.value;
+    return e.conditionFn(s);
   }
 }
-class O {
+class se {
   /**
    * Парсит путь в массив сегментов
    *
@@ -1152,22 +1226,22 @@ class O {
    */
   parsePath(e) {
     const t = [];
-    let i = "", s = !1;
-    for (let a = 0; a < e.length; a++) {
-      const n = e[a];
-      n === "[" ? (s = !0, i += n) : n === "]" ? (s = !1, i += n) : n === "." && !s ? 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 });
   }
   /**
@@ -1202,16 +1276,16 @@ class O {
    * ```
    */
   getValueByPath(e, t) {
-    const i = this.parsePath(t);
-    let s = e;
-    for (const a of i) {
-      if (s == null) return;
-      if (s = s[a.key], a.index !== void 0) {
-        if (!Array.isArray(s)) return;
-        s = s[a.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 s;
+    return i;
   }
   /**
    * Устанавливает значение по пути в объекте (мутирует объект)
@@ -1240,31 +1314,31 @@ class O {
    * // obj3.items[0].title === 'New'
    * ```
    */
-  setValueByPath(e, t, i) {
-    const s = this.parsePath(t);
-    if (s.length === 0)
+  setValueByPath(e, t, s) {
+    const i = this.parsePath(t);
+    if (i.length === 0)
       throw new Error("Cannot set value: empty path");
-    let a = e;
-    for (let o = 0; o < s.length - 1; o++) {
-      const u = s[o];
-      let h = a[u.key];
-      if (u.index !== void 0) {
-        if (!Array.isArray(h))
-          throw new Error(`Expected array at path segment: ${u.key}, but got ${typeof h}`);
-        a = h[u.index];
+    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(u))
+          throw new Error(`Expected array at path segment: ${l.key}, but got ${typeof u}`);
+        r = u[l.index];
       } else
-        h == null && (a[u.key] = {}, h = a[u.key]), a = h;
+        u == null && (r[l.key] = {}, u = r[l.key]), r = u;
     }
-    const n = s[s.length - 1];
+    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] = i;
+      o[n.index] = s;
     } else
-      a[n.key] = i;
+      r[n.key] = s;
   }
   /**
    * Получить значение из FormNode по пути
@@ -1301,9 +1375,9 @@ class O {
    * ```
    */
   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
@@ -1361,560 +1435,224 @@ class O {
    * ```
    */
   getNodeByPath(e, t) {
-    const i = this.parsePath(t);
-    let s = e;
-    for (const a of i) {
-      if (s == null) return null;
-      const n = s;
+    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 (s = n.fields.get(a.key), a.index === void 0) {
-          if (s == null) return null;
+        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) || (s = o[a.index], s == null)) return null;
+        if (!Array.isArray(o) || (i = o[r.index], i == null)) return null;
         continue;
-      } else if (a.index === void 0) {
-        if (s = n[a.key], s == null) return null;
+      } else if (r.index === void 0) {
+        if (i = n[r.key], i == null) return null;
         continue;
       }
-      if (s && a.index !== void 0 && s.items) {
-        const o = s.items.value || s.items;
+      if (i && r.index !== void 0 && i.items) {
+        const o = i.items.value || i.items;
         if (!Array.isArray(o)) return null;
-        s = o[a.index];
-      } else if (s && a.index !== void 0 && !s.items)
+        i = o[r.index];
+      } else if (i && r.index !== void 0 && !i.items)
         return null;
-      if (s == null) return null;
+      if (i == null) return null;
     }
-    return s;
+    return i;
   }
 }
-class $ {
-  /**
-   * Внутреннее хранилище полей
-   * Map обеспечивает быструю lookup производительность O(1)
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  fields = /* @__PURE__ */ new Map();
-  /**
-   * Установить поле в реестр
-   *
-   * @param key - Ключ поля (имя свойства в типе T)
-   * @param node - FormNode для этого поля
-   *
-   * @example
-   * ```typescript
-   * registry.set('email', new FieldNode({ value: '' }));
-   * ```
-   */
-  set(e, t) {
-    this.fields.set(e, t);
-  }
-  /**
-   * Получить поле из реестра
-   *
-   * @param key - Ключ поля
-   * @returns FormNode или undefined, если поле не найдено
-   *
-   * @example
-   * ```typescript
-   * const emailField = registry.get('email');
-   * if (emailField) {
-   *   console.log(emailField.value.value);
-   * }
-   * ```
-   */
-  get(e) {
-    return this.fields.get(e);
-  }
-  /**
-   * Проверить наличие поля в реестре
-   *
-   * @param key - Ключ поля
-   * @returns true если поле существует
-   *
-   * @example
-   * ```typescript
-   * if (registry.has('email')) {
-   *   console.log('Email field exists');
-   * }
-   * ```
-   */
-  has(e) {
-    return this.fields.has(e);
-  }
-  /**
-   * Удалить поле из реестра
-   *
-   * @param key - Ключ поля
-   * @returns true если поле было удалено, false если поля не было
-   *
-   * @example
-   * ```typescript
-   * registry.delete('email');
-   * ```
-   */
-  delete(e) {
-    return this.fields.delete(e);
-  }
-  /**
-   * Перебрать все поля
-   *
-   * @param callback - Функция обратного вызова для каждого поля
-   *
-   * @example
-   * ```typescript
-   * registry.forEach((field, key) => {
-   *   console.log(`${key}: ${field.value.value}`);
-   * });
-   * ```
-   */
-  forEach(e) {
-    this.fields.forEach(e);
-  }
-  /**
-   * Получить итератор значений (полей)
-   *
-   * @returns Итератор по всем полям
-   *
-   * @example
-   * ```typescript
-   * for (const field of registry.values()) {
-   *   await field.validate();
-   * }
-   * ```
-   */
-  values() {
-    return this.fields.values();
-  }
-  /**
-   * Получить итератор пар [ключ, значение]
-   *
-   * @returns Итератор по всем записям
-   *
-   * @example
-   * ```typescript
-   * for (const [key, field] of registry.entries()) {
-   *   console.log(key, field.value.value);
-   * }
-   * ```
-   */
-  entries() {
-    return this.fields.entries();
-  }
-  /**
-   * Получить итератор ключей полей
-   *
-   * @returns Итератор по всем ключам
-   *
-   * @example
-   * ```typescript
-   * const fieldNames = Array.from(registry.keys());
-   * // ['email', 'name', 'age']
-   * ```
-   */
-  keys() {
-    return this.fields.keys();
-  }
-  /**
-   * Получить количество полей
-   *
-   * @returns Количество зарегистрированных полей
-   *
-   * @example
-   * ```typescript
-   * console.log(`Form has ${registry.size()} fields`);
-   * ```
-   */
-  size() {
-    return this.fields.size;
-  }
-  /**
-   * Очистить все поля
-   *
-   * Удаляет все поля из реестра
-   *
-   * @example
-   * ```typescript
-   * registry.clear();
-   * console.log(registry.size()); // 0
-   * ```
-   */
-  clear() {
-    this.fields.clear();
-  }
-  /**
-   * Получить все поля как массив
-   *
-   * Полезно для операций, требующих работу с массивом
-   *
-   * @returns Массив всех полей
-   *
-   * @example
-   * ```typescript
-   * const allValid = registry.toArray().every(field => field.valid.value);
-   * ```
-   */
-  toArray() {
-    return Array.from(this.fields.values());
-  }
-  /**
-   * Получить Map-представление реестра (readonly)
-   *
-   * Используйте для совместимости с существующим кодом
-   *
-   * @returns ReadonlyMap с полями
-   * @internal
-   *
-   * @example
-   * ```typescript
-   * const mapView = registry.asMap();
-   * ```
-   */
-  asMap() {
-    return this.fields;
-  }
+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
+  };
 }
-class G {
+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 fieldRegistry - Реестр полей для доступа к коллекции
+   * @param form - Форма для отправки
    */
   constructor(e) {
-    this.fieldRegistry = e;
+    this.form = e;
   }
+  /** Внутренний сигнал состояния отправки */
+  _submitting = g(!1);
+  /** Публичный read-only сигнал состояния отправки */
+  submitting = d(() => this._submitting.value);
   /**
-   * Создать Proxy для GroupNode
+   * Отправить форму
    *
-   * Proxy позволяет обращаться к полям формы напрямую:
-   * - form.email вместо form.fields.get('email')
-   * - form.address.city вместо form.fields.get('address').fields.get('city')
+   * Процесс:
+   * 1. Помечает все поля как touched (для отображения ошибок)
+   * 2. Валидирует форму
+   * 3. Если валидация успешна - вызывает onSubmit
+   * 4. Управляет состоянием submitting
    *
-   * @param target - GroupNode для которого создается Proxy
-   * @returns Proxy с типобезопасным доступом к полям
+   * @param onSubmit - Callback для отправки данных
+   * @param options - Опции submit
+   * @returns Результат от onSubmit или null если валидация не пройдена
    *
    * @example
    * ```typescript
-   * const proxy = proxyBuilder.build(groupNode);
-   *
-   * // Доступ к полям
-   * console.log(proxy.email.value); // Работает!
-   * console.log(proxy.name.value);  // Работает!
-   *
-   * // Доступ к методам GroupNode
-   * await proxy.validate(); // Работает!
-   * proxy.markAsTouched();  // Работает!
-   *
-   * // Проверка существования
-   * if ('email' in proxy) { ... }
+   * const result = await submitter.submit(async (values) => {
+   *   const response = await fetch('/api/form', {
+   *     method: 'POST',
+   *     body: JSON.stringify(values)
+   *   });
+   *   return response.json();
+   * });
    *
-   * // Перечисление ключей
-   * Object.keys(proxy); // ['email', 'name', ...]
+   * if (result === null) {
+   *   console.log('Форма не прошла валидацию');
+   * }
    * ```
    */
-  build(e) {
-    return new Proxy(e, {
-      /**
-       * Get trap: Перехват доступа к свойствам
-       *
-       * Приоритет:
-       * 1. Собственные свойства и методы GroupNode (validate, setValue и т.д.)
-       * 2. Поля формы из fieldRegistry
-       * 3. undefined для несуществующих свойств
-       */
-      get: (t, i) => {
-        if (i in t)
-          return t[i];
-        if (typeof i == "string" && this.fieldRegistry.has(i))
-          return this.fieldRegistry.get(i);
-      },
-      /**
-       * Set trap: Перехват установки свойств
-       *
-       * Запрещает прямую установку значений полей через form.email = value
-       * Пользователь должен использовать form.email.setValue(value) или form.setValue({...})
-       */
-      set: (t, i, s) => typeof i == "string" && this.fieldRegistry.has(i) ? !1 : (t[i] = s, !0),
-      /**
-       * Has trap: Перехват оператора 'in'
-       *
-       * Позволяет проверять существование полей:
-       * if ('email' in form) { ... }
-       */
-      has: (t, i) => typeof i == "string" && this.fieldRegistry.has(i) ? !0 : i in t,
-      /**
-       * OwnKeys trap: Перехват Object.keys() / Object.getOwnPropertyNames()
-       *
-       * Возвращает объединенный список:
-       * - Ключей самого GroupNode
-       * - Ключей полей из fieldRegistry
-       */
-      ownKeys: (t) => {
-        const i = Reflect.ownKeys(t), s = Array.from(this.fieldRegistry.keys());
-        return [.../* @__PURE__ */ new Set([...i, ...s])];
-      },
-      /**
-       * GetOwnPropertyDescriptor trap: Перехват Object.getOwnPropertyDescriptor()
-       *
-       * Возвращает дескриптор свойства для полей и свойств GroupNode
-       * Важно для корректной работы Object.keys() и других рефлексивных операций
-       */
-      getOwnPropertyDescriptor: (t, i) => typeof i == "string" && this.fieldRegistry.has(i) ? {
-        enumerable: !0,
-        // Поле должно быть перечисляемым
-        configurable: !0
-        // Поле может быть удалено
-        // Не указываем writable, т.к. это accessor property через get/set traps
-      } : Reflect.getOwnPropertyDescriptor(t, i)
-    });
+  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;
+    }
   }
-}
-class U {
-  // ============================================================================
-  // Конструктор
-  // ============================================================================
   /**
-   * Создать менеджер состояния
+   * Отправить форму с расширенным результатом
    *
-   * @param fieldRegistry - реестр полей формы
-   */
-  constructor(e) {
-    this.fieldRegistry = e, this._submitting = d(!1), this._disabled = d(!1), this._formErrors = d([]), this.value = l(() => {
-      const t = {};
-      return this.fieldRegistry.forEach((i, s) => {
-        t[s] = i.value.value;
-      }), t;
-    }), this.valid = l(() => this._formErrors.value.length > 0 ? !1 : Array.from(this.fieldRegistry.values()).every((i) => i.valid.value)), this.invalid = l(() => !this.valid.value), this.pending = l(
-      () => Array.from(this.fieldRegistry.values()).some((t) => t.pending.value)
-    ), this.touched = l(
-      () => Array.from(this.fieldRegistry.values()).some((t) => t.touched.value)
-    ), this.dirty = l(
-      () => Array.from(this.fieldRegistry.values()).some((t) => t.dirty.value)
-    ), this.errors = l(() => {
-      const t = [];
-      return t.push(...this._formErrors.value), this.fieldRegistry.forEach((i) => {
-        t.push(...i.errors.value);
-      }), t;
-    }), this.status = l(() => this._disabled.value ? "disabled" : this.pending.value ? "pending" : this.invalid.value ? "invalid" : "valid"), this.submitting = l(() => this._submitting.value);
-  }
-  // ============================================================================
-  // Приватные сигналы (мутабельные)
-  // ============================================================================
-  /**
-   * Флаг отправки формы
-   * Устанавливается в true во время отправки формы на сервер
-   */
-  _submitting;
-  /**
-   * Флаг disabled состояния
-   * Если true, форма считается disabled
-   */
-  _disabled;
-  /**
-   * Form-level validation errors (не связанные с конкретным полем)
-   * Используется для server-side errors или кросс-полевой валидации
-   */
-  _formErrors;
-  // ============================================================================
-  // Публичные computed signals (read-only)
-  // ============================================================================
-  /**
-   * Значение формы как объект
+   * В отличие от submit(), возвращает объект с информацией об успехе/ошибке
    *
-   * Computed signal, который автоматически пересчитывается при изменении любого поля.
-   * Использует мемоизацию - если зависимости не изменились, вернет закешированный объект.
+   * @param onSubmit - Callback для отправки данных
+   * @param options - Опции submit
+   * @returns Объект SubmitResult с данными и статусом
    *
    * @example
    * ```typescript
-   * const form = new GroupNode({ email: { value: 'test@mail.com' } });
-   * console.log(form.value.value); // { email: 'test@mail.com' }
-   * ```
-   */
-  value;
-  /**
-   * Форма валидна?
-   *
-   * Computed signal. Форма валидна, если:
-   * - Нет form-level errors
-   * - Все поля валидны
-   */
-  valid;
-  /**
-   * Форма невалидна?
-   *
-   * Computed signal. Инверсия valid.
-   */
-  invalid;
-  /**
-   * Хотя бы одно поле touched?
-   *
-   * Computed signal. Возвращает true, если хотя бы одно поле было touched.
-   */
-  touched;
-  /**
-   * Хотя бы одно поле dirty?
-   *
-   * Computed signal. Возвращает true, если хотя бы одно поле изменилось.
-   */
-  dirty;
-  /**
-   * Асинхронная валидация в процессе?
-   *
-   * Computed signal. Возвращает true, если хотя бы одно поле находится в pending состоянии.
-   */
-  pending;
-  /**
-   * Все ошибки валидации
-   *
-   * Computed signal. Возвращает массив всех ошибок:
-   * - Form-level errors
-   * - Field-level errors (из всех вложенных полей)
-   */
-  errors;
-  /**
-   * Общий статус формы
-   *
-   * Computed signal. Возможные значения:
-   * - 'disabled' - форма disabled
-   * - 'pending' - асинхронная валидация в процессе
-   * - 'invalid' - форма невалидна
-   * - 'valid' - форма валидна
-   */
-  status;
-  /**
-   * Форма в процессе отправки?
-   *
-   * Computed signal (обертка над _submitting для read-only доступа).
-   */
-  submitting;
-  // ============================================================================
-  // Публичные методы для управления состоянием
-  // ============================================================================
-  /**
-   * Установить form-level ошибки
-   *
-   * @param errors - массив ошибок валидации
-   *
-   * @example
-   * ```typescript
-   * // Server-side ошибки
-   * stateManager.setFormErrors([
-   *   { code: 'server_error', message: 'Пользователь с таким email уже существует' }
-   * ]);
-   * ```
-   */
-  setFormErrors(e) {
-    this._formErrors.value = e;
-  }
-  /**
-   * Очистить form-level ошибки
-   */
-  clearFormErrors() {
-    this._formErrors.value = [];
-  }
-  /**
-   * Получить form-level ошибки
-   */
-  getFormErrors() {
-    return this._formErrors.value;
-  }
-  /**
-   * Установить флаг submitting
-   *
-   * @param value - true если форма отправляется, false если нет
+   * const result = await submitter.submitWithResult(async (values) => {
+   *   return await api.saveForm(values);
+   * });
    *
-   * @example
-   * ```typescript
-   * stateManager.setSubmitting(true);
-   * await api.submitForm(form.getValue());
-   * stateManager.setSubmitting(false);
+   * if (result.success) {
+   *   console.log('Сохранено:', result.data);
+   * } else if (result.error) {
+   *   console.error('Ошибка:', result.error.message);
+   * } else {
+   *   console.log('Валидация не пройдена');
+   * }
    * ```
    */
-  setSubmitting(e) {
-    this._submitting.value = e;
-  }
-  /**
-   * Установить флаг disabled
-   *
-   * @param value - true если форма disabled, false если нет
-   */
-  setDisabled(e) {
-    this._disabled.value = e;
+  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;
+    }
   }
   /**
-   * Получить флаг disabled
+   * Проверить, идет ли отправка формы
    */
-  isDisabled() {
-    return this._disabled.value;
+  isSubmitting() {
+    return this._submitting.value;
   }
 }
-class m extends A {
+class k extends C {
   // ============================================================================
   // Приватные поля
   // ============================================================================
-  id = D();
-  /**
-   * Реестр полей формы
-   * Использует FieldRegistry для инкапсуляции логики управления коллекцией полей
-   */
-  fieldRegistry;
-  /**
-   * Строитель Proxy для типобезопасного доступа к полям
-   * Использует ProxyBuilder для создания Proxy с расширенной функциональностью
-   */
-  proxyBuilder;
+  id = crypto.randomUUID();
   /**
-   * Менеджер состояния формы
-   * Инкапсулирует всю логику создания и управления сигналами состояния
-   * Извлечен из GroupNode для соблюдения SRP
+   * Коллекция полей формы (упрощённый Map вместо FieldRegistry)
    */
-  stateManager;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  _fields = /* @__PURE__ */ new Map();
   /**
    * Менеджер подписок для централизованного cleanup
-   * Использует SubscriptionManager вместо массива для управления подписками
    */
-  disposers = new _();
+  disposers = new D();
   /**
    * Ссылка на Proxy-инстанс для использования в BehaviorContext
-   * Устанавливается в конструкторе до применения behavior schema
    */
   _proxyInstance;
   /**
    * Навигатор для работы с путями к полям
-   * Использует композицию вместо дублирования логики парсинга путей
    */
-  pathNavigator = new O();
+  pathNavigator = new se();
   /**
    * Фабрика для создания узлов формы
-   * Использует композицию для централизованного создания FieldNode/GroupNode/ArrayNode
    */
-  nodeFactory = new L();
+  nodeFactory = new ne();
   /**
    * Реестр валидаторов для этой формы
-   * Использует композицию вместо глобального Singleton
-   * Обеспечивает полную изоляцию форм друг от друга
+   * Может быть инжектирован через config._validationRegistry для тестирования
    */
-  validationRegistry = new C();
+  validationRegistry;
   /**
    * Реестр behaviors для этой формы
-   * Использует композицию вместо глобального Singleton
-   * Обеспечивает полную изоляцию форм друг от друга
+   * Может быть инжектирован через config._behaviorRegistry для тестирования
    */
-  behaviorRegistry = new T();
+  behaviorRegistry;
   /**
    * Аппликатор для применения валидаторов к форме
-   * Извлечен из GroupNode для соблюдения SRP
-   * Использует композицию для управления процессом валидации
-   */
-  validationApplicator = new N(this);
-  /**
-   * Аппликатор для применения behavior схемы к форме
-   * Извлечен из GroupNode для соблюдения SRP
-   * Использует композицию для управления процессом применения behaviors
    */
-  behaviorApplicator = new B(this, this.behaviorRegistry);
+  validationApplicator = new te(this);
   // ============================================================================
-  // Публичные computed signals (делегированы в StateManager)
+  // Приватные сигналы состояния (inline из StateManager)
+  // ============================================================================
+  /** Управление отправкой формы */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  formSubmitter;
+  /** Флаг disabled состояния */
+  _disabled = g(!1);
+  /** Form-level validation errors */
+  _formErrors = g([]);
+  // ============================================================================
+  // Публичные computed signals
   // ============================================================================
   value;
   valid;
@@ -1926,36 +1664,58 @@ class m extends A {
   status;
   submitting;
   constructor(e) {
-    super(), this.fieldRegistry = new $(), this.proxyBuilder = new G(this.fieldRegistry);
-    const t = "form" in e, i = t ? e.form : e, s = t ? e.behavior : void 0, a = t ? e.validation : void 0;
-    for (const [o, u] of Object.entries(i)) {
-      const h = this.createNode(u);
-      this.fieldRegistry.set(o, h);
+    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.stateManager = new U(this.fieldRegistry), this.value = this.stateManager.value, this.valid = this.stateManager.valid, this.invalid = this.stateManager.invalid, this.touched = this.stateManager.touched, this.dirty = this.stateManager.dirty, this.pending = this.stateManager.pending, this.errors = this.stateManager.errors, this.status = this.stateManager.status, this.submitting = this.stateManager.submitting;
-    const n = this.proxyBuilder.build(this);
-    return this._proxyInstance = n, s && this.applyBehaviorSchema(s), a && this.applyValidationSchema(a), n;
+    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() {
+    return re(this, this._fields);
   }
   // ============================================================================
   // Реализация абстрактных методов FormNode
   // ============================================================================
   getValue() {
     const e = {};
-    return this.fieldRegistry.forEach((t, i) => {
-      e[i] = t.getValue();
+    return this._fields.forEach((t, s) => {
+      e[s] = t.getValue();
     }), e;
   }
   setValue(e, t) {
-    for (const [i, s] of Object.entries(e)) {
-      const a = this.fieldRegistry.get(i);
-      a && a.setValue(s, t);
+    for (const [s, i] of Object.entries(e)) {
+      const r = this._fields.get(s);
+      r && r.setValue(i, t);
     }
   }
   patchValue(e) {
-    for (const [t, i] of Object.entries(e)) {
-      const s = this.fieldRegistry.get(t);
-      s && i !== void 0 && s.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 });
+      }
+    });
   }
   /**
    * Сбросить форму к указанным значениям (или к initialValues)
@@ -1975,103 +1735,49 @@ class m extends A {
    * ```
    */
   reset(e) {
-    this.fieldRegistry.forEach((t, i) => {
-      const s = e?.[i];
-      t.reset(s);
+    this._fields.forEach((t, s) => {
+      const i = e?.[s];
+      t.reset(i);
     });
   }
   /**
    * Сбросить форму к исходным значениям (initialValues)
-   *
-   * @remarks
-   * Рекурсивно вызывает resetToInitial() для всех полей формы.
-   * Более явный способ сброса к начальным значениям по сравнению с reset()
-   *
-   * Полезно когда:
-   * - Пользователь нажал "Cancel" - полная отмена изменений
-   * - Форма была изменена через reset(newValues), но нужно вернуться к самому началу
-   * - Явное намерение показать "отмена всех изменений"
-   *
-   * @example
-   * ```typescript
-   * const form = new GroupNode({
-   *   email: { value: 'initial@mail.com', component: Input },
-   *   name: { value: 'John', component: Input }
-   * });
-   *
-   * form.email.setValue('changed@mail.com');
-   * form.reset({ email: 'temp@mail.com', name: 'Jane' });
-   * console.log(form.getValue()); // { email: 'temp@mail.com', name: 'Jane' }
-   *
-   * form.resetToInitial();
-   * console.log(form.getValue()); // { email: 'initial@mail.com', name: 'John' }
-   * ```
    */
   resetToInitial() {
-    this.fieldRegistry.forEach((e) => {
+    this._fields.forEach((e) => {
       "resetToInitial" in e && typeof e.resetToInitial == "function" ? e.resetToInitial() : e.reset();
     });
   }
   async validate() {
-    this.clearErrors(), await Promise.all(Array.from(this.fieldRegistry.values()).map((t) => t.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.fieldRegistry.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
-   * Используется для server-side validation или кросс-полевых ошибок
-   *
-   * @param errors - массив ошибок уровня формы
-   *
-   * @example
-   * ```typescript
-   * // Server-side validation после submit
-   * try {
-   *   await api.createUser(form.getValue());
-   * } catch (error) {
-   *   form.setErrors([
-   *     { code: 'duplicate_email', message: 'Email уже используется' }
-   *   ]);
-   * }
-   * ```
    */
   setErrors(e) {
-    this.stateManager.setFormErrors(e);
+    this._formErrors.value = e;
   }
   /**
    * Очистить все errors (form-level + field-level)
    */
   clearErrors() {
-    this.stateManager.clearFormErrors(), this.fieldRegistry.forEach((e) => e.clearErrors());
+    this._formErrors.value = [], this._fields.forEach((e) => e.clearErrors());
   }
   /**
    * Получить поле по ключу
-   *
-   * Публичный метод для доступа к полю из fieldRegistry
-   *
-   * @param key - Ключ поля
-   * @returns FormNode или undefined, если поле не найдено
-   *
-   * @example
-   * ```typescript
-   * const emailField = form.getField('email');
-   * if (emailField) {
-   *   console.log(emailField.value.value);
-   * }
-   * ```
    */
   getField(e) {
-    return this.fieldRegistry.get(e);
+    return this._fields.get(e);
   }
   /**
-   * Получить Map всех полей формы
-   *
-   * Используется в FieldPathNavigator для навигации по полям
-   *
-   * @returns Map полей формы
+   * Получить Map всех полей формы (для совместимости)
    */
   get fields() {
-    return this.fieldRegistry;
+    return this._fields;
   }
   /**
    * Получить Proxy-инстанс для прямого доступа к полям
@@ -2100,77 +1806,51 @@ class m extends A {
    * ```
    */
   getProxy() {
-    return this._proxyInstance || this;
+    return this._proxyInstance || (this._proxyInstance = this.buildProxy()), this._proxyInstance;
   }
   /**
    * Получить все поля формы как итератор
-   *
-   * Предоставляет доступ к внутренним полям для валидации и других операций
-   *
-   * @returns Итератор по всем полям формы
-   *
-   * @example
-   * ```typescript
-   * // Валидация всех полей
-   * await Promise.all(
-   *   Array.from(form.getAllFields()).map(field => field.validate())
-   * );
-   * ```
    */
   getAllFields() {
-    return this.fieldRegistry.values();
+    return this._fields.values();
   }
   // ============================================================================
   // Protected hooks (Template Method pattern)
   // ============================================================================
-  /**
-   * Hook: вызывается после markAsTouched()
-   *
-   * Для GroupNode: рекурсивно помечаем все дочерние поля как touched
-   */
   onMarkAsTouched() {
-    this.fieldRegistry.forEach((e) => e.markAsTouched());
+    this._fields.forEach((e) => e.markAsTouched());
   }
-  /**
-   * Hook: вызывается после markAsUntouched()
-   *
-   * Для GroupNode: рекурсивно помечаем все дочерние поля как untouched
-   */
   onMarkAsUntouched() {
-    this.fieldRegistry.forEach((e) => e.markAsUntouched());
+    this._fields.forEach((e) => e.markAsUntouched());
   }
-  /**
-   * Hook: вызывается после markAsDirty()
-   *
-   * Для GroupNode: рекурсивно помечаем все дочерние поля как dirty
-   */
   onMarkAsDirty() {
-    this.fieldRegistry.forEach((e) => e.markAsDirty());
+    this._fields.forEach((e) => e.markAsDirty());
   }
-  /**
-   * Hook: вызывается после markAsPristine()
-   *
-   * Для GroupNode: рекурсивно помечаем все дочерние поля как pristine
-   */
   onMarkAsPristine() {
-    this.fieldRegistry.forEach((e) => e.markAsPristine());
+    this._fields.forEach((e) => e.markAsPristine());
   }
   // ============================================================================
   // Дополнительные методы (из FormStore)
   // ============================================================================
   /**
    * Отправить форму
-   * Валидирует форму и вызывает onSubmit если форма валидна
+   *
+   * @param onSubmit - Callback для отправки данных
+   * @param options - Опции submit (skipValidation, skipTouch)
+   * @returns Результат от onSubmit или null если валидация не пройдена
    */
-  async submit(e) {
-    if (this.markAsTouched(), !await this.validate())
-      return null;
-    this.stateManager.setSubmitting(!0);
-    try {
-      return await e(this.getValue());
-    } finally {
-      this.stateManager.setSubmitting(!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 к форме
@@ -2181,54 +1861,26 @@ class m extends A {
   applyValidationSchema(e) {
     this.validationRegistry.beginRegistration();
     try {
-      const t = x();
+      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;
     }
   }
   /**
    * Применить behavior schema к форме
-   *
-   * ✅ РЕФАКТОРИНГ: Делегирование BehaviorApplicator (SRP)
-   *
-   * Логика применения behavior схемы извлечена в BehaviorApplicator для:
-   * - Соблюдения Single Responsibility Principle
-   * - Уменьшения размера GroupNode (~50 строк)
-   * - Улучшения тестируемости
-   * - Консистентности с ValidationApplicator
-   *
-   * @param schemaFn Функция описания поведения формы
    * @returns Функция cleanup для отписки от всех behaviors
-   *
-   * @example
-   * ```typescript
-   * import { copyFrom, enableWhen, computeFrom } from '@/lib/forms/core/behaviors';
-   *
-   * const behaviorSchema: BehaviorSchemaFn<MyForm> = (path) => {
-   *   copyFrom(path.residenceAddress, path.registrationAddress, {
-   *     when: (form) => form.sameAsRegistration === true
-   *   });
-   *
-   *   enableWhen(path.propertyValue, (form) => form.loanType === 'mortgage');
-   *
-   *   computeFrom(
-   *     path.initialPayment,
-   *     [path.propertyValue],
-   *     (propertyValue) => propertyValue ? propertyValue * 0.2 : null
-   *   );
-   * };
-   *
-   * const cleanup = form.applyBehaviorSchema(behaviorSchema);
-   *
-   * // Cleanup при unmount
-   * useEffect(() => cleanup, []);
-   * ```
    */
   applyBehaviorSchema(e) {
-    return this.behaviorApplicator.apply(e);
+    this.behaviorRegistry.beginRegistration();
+    try {
+      const t = I();
+      return e(t), this.behaviorRegistry.endRegistration(this.getProxy()).cleanup;
+    } catch (t) {
+      throw console.error("Error applying behavior schema:", t), t;
+    }
   }
   /**
    * Получить вложенное поле по пути
@@ -2265,18 +1917,18 @@ class m extends A {
     const t = this.pathNavigator.parsePath(e);
     if (t.length === 0)
       return;
-    let i = this;
-    for (const s of t) {
-      if (!(i instanceof m) || (i = i.getField(s.key), !i)) return;
-      if (s.index !== void 0)
-        if ("at" in i && "length" in i && typeof i.at == "function") {
-          const a = i.at(s.index);
-          if (!a) return;
-          i = a;
+    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 валидаторы к полям
@@ -2319,39 +1971,17 @@ class m extends A {
   // ============================================================================
   /**
    * Связывает два поля: при изменении source автоматически обновляется target
-   * Поддерживает опциональную трансформацию значения
-   *
-   * @param sourceKey - Ключ поля-источника
-   * @param targetKey - Ключ поля-цели
-   * @param transform - Опциональная функция трансформации значения
-   * @returns Функция отписки для cleanup
-   *
-   * @example
-   * ```typescript
-   * // Автоматический расчет минимального взноса от стоимости недвижимости
-   * const dispose = form.linkFields(
-   *   'propertyValue',
-   *   'initialPayment',
-   *   (propertyValue) => propertyValue ? propertyValue * 0.2 : null
-   * );
-   *
-   * // При изменении propertyValue → автоматически обновится initialPayment
-   * form.propertyValue.setValue(1000000);
-   * // initialPayment станет 200000
-   *
-   * // Cleanup
-   * useEffect(() => dispose, []);
-   * ```
    */
-  linkFields(e, t, i) {
-    const s = this.fieldRegistry.get(e), a = this.fieldRegistry.get(t);
-    if (!s || !a)
-      return () => {
-      };
-    const n = v(() => {
-      const u = s.value.value, h = i ? i(u) : u;
-      a.setValue(h, { 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);
   }
   /**
@@ -2382,56 +2012,37 @@ class m extends A {
    * ```
    */
   watchField(e, t) {
-    const i = this.getFieldByPath(e);
-    if (!i)
-      return () => {
-      };
-    const s = v(() => {
-      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);
-    }), a = `watchField-${Date.now()}-${Math.random()}`;
-    return this.disposers.add(a, s);
+    }), r = A(w.WatchField);
+    return this.disposers.add(r, i);
   }
   /**
    * Hook: вызывается после disable()
-   *
-   * Для GroupNode: рекурсивно отключаем все дочерние поля
    */
   onDisable() {
-    this.stateManager.setDisabled(!0), this.fieldRegistry.forEach((e) => {
-      e.disable();
-    });
+    this._disabled.value = !0, this._fields.forEach((e) => e.disable());
   }
   /**
    * Hook: вызывается после enable()
-   *
-   * Для GroupNode: рекурсивно включаем все дочерние поля
    */
   onEnable() {
-    this.stateManager.setDisabled(!1), this.fieldRegistry.forEach((e) => {
-      e.enable();
-    });
+    this._disabled.value = !1, this._fields.forEach((e) => e.enable());
   }
   /**
    * Очистить все ресурсы узла
-   * Рекурсивно очищает все subscriptions и дочерние узлы
-   *
-   * @example
-   * ```typescript
-   * useEffect(() => {
-   *   return () => {
-   *     form.dispose();
-   *   };
-   * }, []);
-   * ```
    */
   dispose() {
-    this.disposers.dispose(), this.fieldRegistry.forEach((e) => {
+    this.disposers.dispose(), this._fields.forEach((e) => {
       "dispose" in e && typeof e.dispose == "function" && e.dispose();
     });
   }
 }
-class F extends A {
+class L extends C {
   // ============================================================================
   // Приватные поля
   // ============================================================================
@@ -2442,7 +2053,9 @@ class F extends A {
    * Менеджер подписок для централизованного cleanup
    * Использует SubscriptionManager вместо массива для управления подписками
    */
-  disposers = new _();
+  disposers = new D();
+  /** Array-level validation errors (e.g., "минимум 1 элемент") */
+  _arrayErrors = g([]);
   // ============================================================================
   // Приватные поля для сохранения схем
   // ============================================================================
@@ -2464,15 +2077,15 @@ class F extends A {
   // Конструктор
   // ============================================================================
   constructor(e, t = []) {
-    super(), this.itemSchema = e, this.initialItems = t, this.items = d([]);
+    super(), this.itemSchema = e, this.initialItems = t, this.items = g([]);
     for (const i of t)
       this.push(i);
-    this.length = l(() => this.items.value.length), this.value = l(() => this.items.value.map((i) => i.value.value)), this.valid = l(() => this.items.value.every((i) => i.valid.value)), this.invalid = l(() => !this.valid.value), this.pending = l(() => this.items.value.some((i) => i.pending.value)), this.touched = l(() => this.items.value.some((i) => i.touched.value)), this.dirty = l(() => this.items.value.some((i) => i.dirty.value)), this.errors = l(() => {
-      const i = [];
-      return this.items.value.forEach((s) => {
-        i.push(...s.errors.value);
-      }), i;
-    }), this.status = l(() => 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 операции
@@ -2488,9 +2101,23 @@ class F extends A {
   /**
    * Удалить элемент по индексу
    * @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();
   }
   /**
    * Вставить элемент в массив
@@ -2498,24 +2125,40 @@ class F extends A {
    * @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), s = [...this.items.value];
-    s.splice(e, 0, i), this.items.value = s;
+    }
+    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();
   }
   // ============================================================================
   // Реализация абстрактных методов
@@ -2524,12 +2167,13 @@ class F extends A {
     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);
     });
   }
   /**
@@ -2550,7 +2194,7 @@ class F extends A {
    * ```
    */
   reset(e) {
-    this.clear(), e && e.forEach((t) => this.push(t));
+    this._arrayErrors.value = [], this.clear(), e && e.forEach((t) => this.push(t));
   }
   /**
    * Сбросить массив к исходным значениям (initialItems)
@@ -2581,15 +2225,38 @@ class F extends A {
    * ```
    */
   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)
@@ -2631,20 +2298,24 @@ class F extends A {
   // ============================================================================
   /**
    * Итерировать по элементам массива
-   * @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 методы
@@ -2655,7 +2326,7 @@ class F extends A {
    */
   createItem(e) {
     if (this.isGroupSchema(this.itemSchema)) {
-      const t = new m(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(
@@ -2742,14 +2413,14 @@ class F extends A {
    * ```
    */
   watchItems(e, t) {
-    const i = v(() => {
-      const a = this.items.value.map((n) => {
-        if (n instanceof m)
+    const s = m(() => {
+      const r = this.items.value.map((n) => {
+        if (n instanceof k)
           return n.getFieldByPath(e)?.value.value;
       });
-      t(a);
-    }), s = `watchItems-${Date.now()}-${Math.random()}`;
-    return this.disposers.add(s, i);
+      t(r);
+    }), i = A(w.WatchItems);
+    return this.disposers.add(i, s);
   }
   /**
    * Подписка на изменение длины массива
@@ -2774,11 +2445,11 @@ class F extends A {
    * ```
    */
   watchLength(e) {
-    const t = v(() => {
-      const s = this.length.value;
-      e(s);
-    }), 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);
   }
   /**
    * Очистить все ресурсы узла
@@ -2841,7 +2512,7 @@ class F extends A {
     });
   }
 }
-class L {
+class ne {
   /**
    * Создает узел формы на основе конфигурации
    *
@@ -2891,16 +2562,16 @@ class L {
     if (Array.isArray(e) && e.length >= 1)
       return this.createArrayNodeFromArray(e);
     if (this.isFieldConfig(e))
-      return new I(e);
+      return new ee(e);
     if (this.isArrayConfig(e)) {
       const t = e;
-      return new F(
+      return new L(
         t.schema,
         t.initialItems
       );
     }
     if (this.isGroupConfig(e))
-      return new m(e);
+      return new k(e);
     throw new Error(
       `NodeFactory: Unknown node config. Expected FieldConfig, GroupConfig, or ArrayConfig, but got: ${JSON.stringify(
         e
@@ -2934,11 +2605,11 @@ class L {
    */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   createArrayNodeFromArray(e) {
-    const [t, ...i] = e, s = [];
-    this.isGroupConfig(t) && s.push(this.extractValues(t));
-    for (const a of i)
-      this.isGroupConfig(a) ? s.push(this.extractValues(a)) : s.push(a);
-    return new F(t, s);
+    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);
   }
   /**
    * Извлечь значения из схемы (рекурсивно)
@@ -2976,8 +2647,8 @@ class L {
       return e.map((t) => this.extractValues(t));
     if (this.isGroupConfig(e)) {
       const t = {};
-      for (const [i, s] of Object.entries(e))
-        t[i] = this.extractValues(s);
+      for (const [s, i] of Object.entries(e))
+        t[s] = this.extractValues(i);
       return t;
     }
     return e;
@@ -3057,287 +2728,441 @@ class L {
     return e != null && typeof e == "object" && !this.isFieldConfig(e) && !this.isArrayConfig(e);
   }
 }
-class ee {
+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'));
-   *
-   * // Второй вызов через 100мс - отменяет первый, запланирован через 300мс
-   * debouncer.debounce(async () => console.log('Second'));
+   * const dispose = observer.enableTracing();
    *
-   * // Через 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 s = await e();
-          t(s);
-        } catch (s) {
-          i(s);
-        }
-      }, 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 te(r) {
-  return new m(r);
-}
-function j(r) {
-  return {
-    type: "static",
-    load: async () => ({
-      items: r,
-      totalCount: r.length
-    })
-  };
+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() {
+        y.value = c, y.getSnapshot = f, l(y) && E({ inst: y });
+      },
+      [h, c, f]
+    ), i(
+      function() {
+        return l(y) && E({ inst: y }), h(function() {
+          l(y) && E({ inst: y });
+        });
+      },
+      [h]
+    ), n(c), c;
+  }
+  function l(h) {
+    var f = h.getSnapshot;
+    h = h.value;
+    try {
+      var c = f();
+      return !t(h, c);
+    } catch {
+      return !0;
+    }
+  }
+  function u(h, f) {
+    return f();
+  }
+  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;
 }
-function K(r) {
-  let e = null;
-  return {
-    type: "preload",
-    load: async (t) => {
-      if (!e) {
-        const i = await r(t);
-        e = {
-          items: i,
-          totalCount: i.length
-        };
+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(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 y = p();
+      if (!h) {
+        var E = p();
+        r(y, E) || (console.error(
+          "The result of getSnapshot should be cached to avoid an infinite loop"
+        ), h = !0);
       }
-      return e;
+      E = n({
+        inst: { value: y, getSnapshot: p }
+      });
+      var _ = E[0].inst, F = E[1];
+      return l(
+        function() {
+          _.value = y, _.getSnapshot = p, t(_) && F({ inst: _ });
+        },
+        [c, y, p]
+      ), o(
+        function() {
+          return t(_) && F({ inst: _ }), c(function() {
+            t(_) && F({ inst: _ });
+          });
+        },
+        [c]
+      ), u(y), y;
     }
-  };
-}
-function z(r) {
-  return {
-    type: "partial",
-    load: async (e) => {
-      const t = await r(e);
-      return {
-        items: t,
-        totalCount: t.length
-        // Можно расширить для поддержки серверной пагинации
-      };
+    function t(c) {
+      var p = c.getSnapshot;
+      c = c.value;
+      try {
+        var y = p();
+        return !r(c, y);
+      } catch {
+        return !0;
+      }
     }
-  };
+    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 = 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;
 }
-const se = {
-  static: j,
-  preload: K,
-  partial: z
-};
-function k(r, e) {
-  if (r === e) return !0;
-  if (r.length !== e.length) return !1;
-  for (let t = 0; t < r.length; t++)
-    if (r[t] !== e[t]) return !1;
+var $;
+function ue() {
+  return $ || ($ = 1, process.env.NODE_ENV === "production" ? x.exports = oe() : x.exports = le()), x.exports;
+}
+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 W(r) {
-  const e = V({
-    snapshot: null,
-    value: r.value.value,
-    errors: r.errors.value,
-    componentProps: r.componentProps.value,
-    disabled: r.disabled.value,
-    pending: r.pending.value,
-    valid: r.valid.value,
-    invalid: r.invalid.value,
-    touched: r.touched.value,
-    shouldShowError: r.shouldShowError.value
-  }), t = y(
-    (s) => {
-      let a = !0;
-      return v(() => {
-        if (r.value.value, r.disabled.value, r.errors.value, r.pending.value, r.valid.value, r.invalid.value, r.touched.value, r.shouldShowError.value, r.componentProps.value, a) {
-          a = !1;
+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;
+    s.current = { ...n, __snapshot: null };
+  }
+  const i = b(
+    (n) => {
+      let o = !0;
+      return m(() => {
+        for (const u in a)
+          a[u].value;
+        if (o) {
+          o = !1;
           return;
         }
-        s();
+        n();
       });
     },
-    [r]
-  ), i = y(() => {
-    const s = e.current, a = r.value.value, n = r.errors.value, o = r.componentProps.value, u = r.disabled.value, h = r.pending.value, c = r.valid.value, f = r.invalid.value, p = r.touched.value, b = r.shouldShowError.value;
-    return !(s.value !== a || !k(s.errors, n) || s.componentProps !== o || s.disabled !== u || s.pending !== h || s.valid !== c || s.invalid !== f || s.touched !== p || s.shouldShowError !== b) && s.snapshot || (s.value = a, s.errors = n, s.componentProps = o, s.disabled = u, s.pending = h, s.valid = c, s.invalid = f, s.touched = p, s.shouldShowError = b, s.snapshot = {
-      value: a,
-      pending: h,
-      disabled: u,
-      errors: n,
-      valid: c,
-      invalid: f,
-      touched: p,
-      shouldShowError: b,
-      componentProps: o
-    }), s.snapshot;
-  }, [r]);
-  return w(t, i, i);
-}
-function H(r) {
-  const e = V({
-    snapshot: null,
-    value: r.value.value,
-    length: r.length.value,
-    errors: r.errors.value,
-    pending: r.pending.value,
-    valid: r.valid.value,
-    invalid: r.invalid.value,
-    touched: r.touched.value,
-    dirty: r.dirty.value
-  }), t = y(
-    (s) => {
-      let a = !0;
-      return v(() => {
-        if (r.value.value, r.length.value, r.errors.value, r.pending.value, r.valid.value, r.invalid.value, r.touched.value, r.dirty.value, a) {
-          a = !1;
-          return;
+    [a]
+  ), r = b(() => {
+    const n = s.current, o = {};
+    for (const u in a)
+      o[u] = a[u].value;
+    let l = !1;
+    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;
         }
-        s();
-      });
-    },
-    [r]
-  ), i = y(() => {
-    const s = e.current, a = r.value.value, n = r.length.value, o = r.errors.value, u = r.pending.value, h = r.valid.value, c = r.invalid.value, f = r.touched.value, p = r.dirty.value;
-    return !(s.value !== a || s.length !== n || !k(s.errors, o) || s.pending !== u || s.valid !== h || s.invalid !== c || s.touched !== f || s.dirty !== p) && s.snapshot || (s.value = a, s.length = n, s.errors = o, s.pending = u, s.valid = h, s.invalid = c, s.touched = f, s.dirty = p, s.snapshot = {
-      value: a,
-      length: n,
-      pending: u,
-      errors: o,
-      valid: h,
-      invalid: c,
-      touched: f,
-      dirty: p
-    }), s.snapshot;
-  }, [r]);
-  return w(t, i, i);
+      } else if (c !== f) {
+        l = !0;
+        break;
+      }
+    }
+    if (!l && n.__snapshot)
+      return n.__snapshot;
+    for (const u in a)
+      n[u] = o[u];
+    return n.__snapshot = t(o), n.__snapshot;
+  }, [a, t]);
+  return R.useSyncExternalStore(i, r, r);
 }
-function ie(r) {
-  const e = V({
-    value: r.value.value,
-    snapshot: r.value.value
-  }), t = y(
-    (s) => {
-      let a = !0;
-      return v(() => {
-        if (r.value.value, a) {
-          a = !1;
-          return;
-        }
-        s();
-      });
-    },
-    [r]
-  ), i = y(() => {
-    const s = r.value.value;
-    return e.current.value === s ? e.current.snapshot : (e.current.value = s, e.current.snapshot = s, s);
-  }, [r]);
-  return w(t, i, i);
+function de(a) {
+  const e = {
+    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" },
+    { key: "errors", useShallowArrayEqual: !0 },
+    { key: "pending" },
+    { key: "valid" },
+    { key: "invalid" },
+    { key: "touched" },
+    { key: "shouldShowError" },
+    { key: "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 q(e, t, s);
+}
+function ce(a) {
+  const e = {
+    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" },
+    { key: "errors", useShallowArrayEqual: !0 },
+    { key: "pending" },
+    { key: "valid" },
+    { key: "invalid" },
+    { key: "touched" },
+    { key: "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 q(e, t, s);
 }
-function re(r) {
-  const e = r && "length" in r && "map" in r;
-  return r ? e ? H(r) : W(r) : {
+function Ee(a) {
+  const e = a && "length" in a && "map" in a;
+  return a ? e ? ce(a) : de(a) : {
     value: [],
     length: 0,
     pending: !1,
@@ -3348,33 +3173,99 @@ function re(r) {
     dirty: !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;
+        }
+        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 {
-  F as ArrayNode,
-  ee as Debouncer,
-  g as ErrorStrategy,
-  I as FieldNode,
-  O as FieldPathNavigator,
-  E as FormErrorHandler,
-  A as FormNode,
-  m as GroupNode,
-  L as NodeFactory,
-  ye as RegistryStack,
-  se as Resources,
-  _ as SubscriptionManager,
-  oe as behaviors,
-  te as createForm,
-  me as getCurrentBehaviorRegistry,
-  ge as getCurrentValidationRegistry,
-  ue as getNodeType,
-  he as isArrayNode,
-  R as isFieldNode,
-  de as isFormNode,
-  ce as isGroupNode,
-  z as partialResource,
-  K as preloadResource,
-  j as staticResource,
-  re as useFormControl,
-  ie as useFormControlValue,
-  ve as validateForm,
-  fe 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
 };