@reformer/core 1.1.0 → 2.0.0-beta.11

package/dist/index.js

@@ -1,8 +1,3271 @@
-export * from './core/types';
-export * from './core/factories';
-export * from './core/utils';
-export { FormNode } from './core/nodes/form-node';
-export { FieldNode } from './core/nodes/field-node';
-export { GroupNode } from './core/nodes/group-node';
-export { ArrayNode } from './core/nodes/array-node';
-export { useFormControl, useFormControlValue } from './hooks/useFormControl';
+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 паттерна)
+  // ============================================================================
+  /**
+   * Пользователь взаимодействовал с узлом (touched)
+   * Protected: наследники могут читать/изменять через методы
+   */
+  _touched = g(!1);
+  /**
+   * Значение узла было изменено (dirty)
+   * Protected: наследники могут читать/изменять через методы
+   */
+  _dirty = g(!1);
+  /**
+   * Текущий статус узла
+   * Protected: наследники могут читать/изменять через методы
+   */
+  _status = g("valid");
+  // ============================================================================
+  // Публичные computed signals (readonly для внешнего мира)
+  // ============================================================================
+  /**
+   * Пользователь взаимодействовал с узлом (touched)
+   * Computed из _touched для предоставления readonly интерфейса
+   */
+  touched = d(() => this._touched.value);
+  /**
+   * Пользователь не взаимодействовал с узлом (untouched)
+   */
+  untouched = d(() => !this._touched.value);
+  /**
+   * Значение узла было изменено (dirty)
+   * Computed из _dirty для предоставления readonly интерфейса
+   */
+  dirty = d(() => this._dirty.value);
+  /**
+   * Значение узла не было изменено (pristine)
+   */
+  pristine = d(() => !this._dirty.value);
+  /**
+   * Текущий статус узла
+   * Computed из _status для предоставления readonly интерфейса
+   */
+  status = d(() => this._status.value);
+  /**
+   * Узел отключен (disabled)
+   */
+  disabled = d(() => this._status.value === "disabled");
+  /**
+   * Узел включен (enabled)
+   */
+  enabled = d(() => this._status.value !== "disabled");
+  /**
+   * Получить ошибки валидации с фильтрацией
+   *
+   * Позволяет фильтровать ошибки по различным критериям:
+   * - По коду ошибки
+   * - По сообщению (частичное совпадение)
+   * - По параметрам
+   * - Через кастомный предикат
+   *
+   * Без параметров возвращает все ошибки (эквивалент errors.value)
+   *
+   * @param options - Опции фильтрации ошибок
+   * @returns Отфильтрованный массив ошибок валидации
+   *
+   * @example
+   * ```typescript
+   * // Все ошибки
+   * const allErrors = form.getErrors();
+   *
+   * // Ошибки с конкретным кодом
+   * const requiredErrors = form.getErrors({ code: 'required' });
+   *
+   * // Ошибки с несколькими кодами
+   * const errors = form.getErrors({ code: ['required', 'email'] });
+   *
+   * // Ошибки по сообщению
+   * const passwordErrors = form.getErrors({ message: 'Password' });
+   *
+   * // Ошибки по параметрам
+   * const minLengthErrors = form.getErrors({
+   *   params: { minLength: 8 }
+   * });
+   *
+   * // Кастомная фильтрация
+   * const customErrors = form.getErrors({
+   *   predicate: (err) => err.code.startsWith('custom_')
+   * });
+   * ```
+   */
+  getErrors(e) {
+    const t = this.errors.value;
+    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 (!s.params)
+          return !1;
+        for (const [i, r] of Object.entries(e.params))
+          if (s.params[i] !== r)
+            return !1;
+      }
+      return !(e.predicate !== void 0 && !e.predicate(s));
+    }) : t;
+  }
+  // ============================================================================
+  // Методы управления состоянием (Template Method)
+  // ============================================================================
+  /**
+   * Отметить узел как touched (пользователь взаимодействовал)
+   *
+   * Template Method: обновляет signal в базовом классе,
+   * вызывает hook для кастомной логики в наследниках
+   */
+  markAsTouched() {
+    this._touched.value = !0, this.onMarkAsTouched();
+  }
+  /**
+   * Отметить узел как untouched
+   *
+   * Template Method: обновляет signal в базовом классе,
+   * вызывает hook для кастомной логики в наследниках
+   */
+  markAsUntouched() {
+    this._touched.value = !1, this.onMarkAsUntouched();
+  }
+  /**
+   * Отметить узел как dirty (значение изменено)
+   *
+   * Template Method: обновляет signal в базовом классе,
+   * вызывает hook для кастомной логики в наследниках
+   */
+  markAsDirty() {
+    this._dirty.value = !0, this.onMarkAsDirty();
+  }
+  /**
+   * Отметить узел как pristine (значение не изменено)
+   *
+   * Template Method: обновляет signal в базовом классе,
+   * вызывает hook для кастомной логики в наследниках
+   */
+  markAsPristine() {
+    this._dirty.value = !1, this.onMarkAsPristine();
+  }
+  /**
+   * Пометить все поля (включая вложенные) как touched
+   * Алиас для markAsTouched(), но более явно показывает намерение
+   * пометить ВСЕ поля рекурсивно
+   *
+   * Полезно для:
+   * - Показа всех ошибок валидации перед submit
+   * - Принудительного отображения ошибок при нажатии "Validate All"
+   * - Отображения невалидных полей в wizard/step form
+   *
+   * @example
+   * ```typescript
+   * // Показать все ошибки перед submit
+   * form.touchAll();
+   * const isValid = await form.validate();
+   * if (!isValid) {
+   *   // Все ошибки теперь видны пользователю
+   * }
+   *
+   * // Или использовать submit() который уже вызывает touchAll
+   * await form.submit(async (values) => {
+   *   await api.save(values);
+   * });
+   * ```
+   */
+  touchAll() {
+    this.markAsTouched();
+  }
+  // ============================================================================
+  // Методы управления доступностью (Template Method)
+  // ============================================================================
+  /**
+   * Отключить узел
+   *
+   * Template Method: обновляет статус в базовом классе,
+   * вызывает hook для кастомной логики в наследниках
+   *
+   * Отключенные узлы не проходят валидацию и не включаются в getValue()
+   */
+  disable() {
+    this._status.value = "disabled", this.onDisable();
+  }
+  /**
+   * Включить узел
+   *
+   * Template Method: обновляет статус в базовом классе,
+   * вызывает hook для кастомной логики в наследниках
+   */
+  enable() {
+    this._status.value = "valid", this.onEnable();
+  }
+  // ============================================================================
+  // Protected hooks (для переопределения в наследниках)
+  // ============================================================================
+  /**
+   * Hook: вызывается после markAsTouched()
+   *
+   * Переопределите в наследниках для дополнительной логики:
+   * - GroupNode: пометить все дочерние узлы как touched
+   * - ArrayNode: пометить все элементы массива как touched
+   * - FieldNode: пустая реализация (нет дочерних узлов)
+   *
+   * @example
+   * ```typescript
+   * // GroupNode
+   * protected onMarkAsTouched(): void {
+   *   this.fields.forEach(field => field.markAsTouched());
+   * }
+   * ```
+   */
+  onMarkAsTouched() {
+  }
+  /**
+   * Hook: вызывается после markAsUntouched()
+   *
+   * Переопределите в наследниках для дополнительной логики:
+   * - GroupNode: пометить все дочерние узлы как untouched
+   * - ArrayNode: пометить все элементы массива как untouched
+   * - FieldNode: пустая реализация (нет дочерних узлов)
+   */
+  onMarkAsUntouched() {
+  }
+  /**
+   * Hook: вызывается после markAsDirty()
+   *
+   * Переопределите в наследниках для дополнительной логики:
+   * - GroupNode: может обновить родительскую форму
+   * - ArrayNode: может обновить родительскую форму
+   * - FieldNode: пустая реализация
+   */
+  onMarkAsDirty() {
+  }
+  /**
+   * Hook: вызывается после markAsPristine()
+   *
+   * Переопределите в наследниках для дополнительной логики:
+   * - GroupNode: пометить все дочерние узлы как pristine
+   * - ArrayNode: пометить все элементы массива как pristine
+   * - FieldNode: пустая реализация
+   */
+  onMarkAsPristine() {
+  }
+  /**
+   * Hook: вызывается после disable()
+   *
+   * Переопределите в наследниках для дополнительной логики:
+   * - GroupNode: отключить все дочерние узлы
+   * - ArrayNode: отключить все элементы массива
+   * - FieldNode: очистить ошибки валидации
+   *
+   * @example
+   * ```typescript
+   * // GroupNode
+   * protected onDisable(): void {
+   *   this.fields.forEach(field => field.disable());
+   * }
+   * ```
+   */
+  onDisable() {
+  }
+  /**
+   * Hook: вызывается после enable()
+   *
+   * Переопределите в наследниках для дополнительной логики:
+   * - GroupNode: включить все дочерние узлы
+   * - ArrayNode: включить все элементы массива
+   * - FieldNode: пустая реализация
+   */
+  onEnable() {
+  }
+}
+class D {
+  /**
+   * Хранилище подписок
+   * Ключ: уникальный идентификатор подписки
+   * Значение: функция отписки (dispose)
+   */
+  subscriptions = /* @__PURE__ */ new Map();
+  /**
+   * Добавляет подписку
+   *
+   * Если подписка с таким ключом уже существует, отписывается от неё
+   * и заменяет новой. Это предотвращает утечки памяти при повторной
+   * регистрации подписки с тем же ключом.
+   *
+   * @param key Уникальный ключ подписки
+   * @param dispose Функция отписки (обычно возвращаемая из effect())
+   * @returns Функция для отписки от этой конкретной подписки
+   *
+   * @example
+   * ```typescript
+   * const manager = new SubscriptionManager();
+   *
+   * // Добавление подписки
+   * const unsubscribe = manager.add('mySubscription', () => {
+   *   console.log('Disposing subscription');
+   * });
+   *
+   * // Отписка через возвращаемую функцию
+   * unsubscribe();
+   *
+   * // Или через manager.remove()
+   * manager.add('anotherSub', disposeFn);
+   * manager.remove('anotherSub');
+   * ```
+   */
+  add(e, t) {
+    return this.subscriptions.has(e) && (process.env.NODE_ENV !== "production" && console.warn(`[SubscriptionManager] Subscription "${e}" already exists, replacing`), this.subscriptions.get(e)?.()), this.subscriptions.set(e, t), () => this.remove(e);
+  }
+  /**
+   * Удаляет подписку по ключу
+   *
+   * Вызывает функцию отписки и удаляет подписку из хранилища.
+   * Если подписка с таким ключом не найдена, ничего не делает.
+   *
+   * @param key Ключ подписки
+   * @returns true, если подписка была удалена, false если не найдена
+   *
+   * @example
+   * ```typescript
+   * const manager = new SubscriptionManager();
+   * manager.add('mySub', disposeFn);
+   *
+   * // Удаление подписки
+   * const removed = manager.remove('mySub'); // true
+   *
+   * // Попытка удалить несуществующую подписку
+   * const removed2 = manager.remove('nonExistent'); // false
+   * ```
+   */
+  remove(e) {
+    const t = this.subscriptions.get(e);
+    return t ? (t(), this.subscriptions.delete(e), !0) : !1;
+  }
+  /**
+   * Очищает все подписки
+   *
+   * Вызывает функции отписки для всех активных подписок
+   * и очищает хранилище. Обычно используется при dispose узла формы.
+   *
+   * @example
+   * ```typescript
+   * class FieldNode {
+   *   private subscriptions = new SubscriptionManager();
+   *
+   *   dispose() {
+   *     // Отписываемся от всех effect
+   *     this.subscriptions.clear();
+   *   }
+   * }
+   * ```
+   */
+  clear() {
+    this.subscriptions.forEach((e) => {
+      e();
+    }), this.subscriptions.clear();
+  }
+  /**
+   * Возвращает количество активных подписок
+   *
+   * Полезно для отладки утечек памяти. Если количество подписок
+   * растет без ограничений, это может указывать на то, что
+   * компоненты не отписываются должным образом.
+   *
+   * @returns Количество активных подписок
+   *
+   * @example
+   * ```typescript
+   * const manager = new SubscriptionManager();
+   * console.log(manager.size()); // 0
+   *
+   * manager.add('sub1', disposeFn1);
+   * manager.add('sub2', disposeFn2);
+   * console.log(manager.size()); // 2
+   *
+   * manager.clear();
+   * console.log(manager.size()); // 0
+   * ```
+   */
+  size() {
+    return this.subscriptions.size;
+  }
+  /**
+   * Проверяет, есть ли подписка с данным ключом
+   *
+   * @param key Ключ подписки
+   * @returns true, если подписка существует
+   *
+   * @example
+   * ```typescript
+   * const manager = new SubscriptionManager();
+   * manager.add('mySub', disposeFn);
+   *
+   * console.log(manager.has('mySub')); // true
+   * console.log(manager.has('nonExistent')); // false
+   * ```
+   */
+  has(e) {
+    return this.subscriptions.has(e);
+  }
+  /**
+   * Возвращает список всех ключей активных подписок
+   *
+   * Полезно для отладки: можно увидеть, какие подписки активны.
+   *
+   * @returns Массив ключей всех активных подписок
+   *
+   * @example
+   * ```typescript
+   * const manager = new SubscriptionManager();
+   * manager.add('watch-value', disposeFn1);
+   * manager.add('watch-errors', disposeFn2);
+   *
+   * console.log(manager.getKeys()); // ['watch-value', 'watch-errors']
+   * ```
+   */
+  getKeys() {
+    return Array.from(this.subscriptions.keys());
+  }
+  /**
+   * Отписывается от всех подписок (алиас для clear())
+   *
+   * Используется при dispose() узла формы для совместимости с ожидаемым API.
+   *
+   * @example
+   * ```typescript
+   * class FieldNode {
+   *   private subscriptions = new SubscriptionManager();
+   *
+   *   dispose() {
+   *     this.subscriptions.dispose();
+   *   }
+   * }
+   * ```
+   */
+  dispose() {
+    this.clear();
+  }
+}
+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");
+  }
+  /**
+   * Начать валидацию
+   *
+   * Переводит статус в 'pending' если поле не отключено
+   *
+   * @example
+   * ```typescript
+   * statusMachine.startValidation();
+   * // status: 'pending'
+   * ```
+   */
+  startValidation() {
+    this._status.value !== "disabled" && (this._status.value = "pending");
+  }
+  /**
+   * Завершить валидацию
+   *
+   * @param hasErrors - Есть ли ошибки валидации
+   *
+   * @example
+   * ```typescript
+   * // Валидация успешна
+   * statusMachine.completeValidation(false);
+   * // status: 'valid'
+   *
+   * // Есть ошибки
+   * statusMachine.completeValidation(true);
+   * // status: 'invalid'
+   * ```
+   */
+  completeValidation(e) {
+    (this._status.value === "pending" || this._status.value !== "disabled") && (this._status.value = e ? "invalid" : "valid");
+  }
+  /**
+   * Установить ошибки напрямую (без перехода через pending)
+   *
+   * Используется для синхронной валидации или установки ошибок извне
+   *
+   * @param hasErrors - Есть ли ошибки
+   *
+   * @example
+   * ```typescript
+   * statusMachine.setErrors(true);
+   * // status: 'invalid'
+   * ```
+   */
+  setErrors(e) {
+    this._status.value !== "disabled" && (this._status.value = e ? "invalid" : "valid");
+  }
+  /**
+   * Отключить поле
+   *
+   * Переводит статус в 'disabled'
+   *
+   * @example
+   * ```typescript
+   * statusMachine.disable();
+   * // status: 'disabled'
+   * ```
+   */
+  disable() {
+    this._status.value = "disabled";
+  }
+  /**
+   * Включить поле
+   *
+   * @param hasErrors - Есть ли ошибки (определяет valid/invalid)
+   *
+   * @example
+   * ```typescript
+   * statusMachine.enable(false);
+   * // status: 'valid'
+   *
+   * statusMachine.enable(true);
+   * // status: 'invalid'
+   * ```
+   */
+  enable(e = !1) {
+    this._status.value = e ? "invalid" : "valid";
+  }
+  /**
+   * Обработать событие (альтернативный API)
+   *
+   * @param event - Событие для обработки
+   *
+   * @example
+   * ```typescript
+   * statusMachine.dispatch({ type: 'START_VALIDATION' });
+   * statusMachine.dispatch({ type: 'VALIDATION_FAILURE' });
+   * ```
+   */
+  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 ee extends C {
+  // ============================================================================
+  // Приватные сигналы
+  // ============================================================================
+  _value;
+  _errors;
+  // _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;
+  pending;
+  // Override status и disabled из базового класса
+  status;
+  disabled;
+  // touched, dirty наследуются от FormNode
+  errors;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  componentProps;
+  /**
+   * Вычисляемое свойство: нужно ли показывать ошибку
+   * Ошибка показывается если поле невалидно И (touched ИЛИ dirty)
+   */
+  shouldShowError;
+  // ============================================================================
+  // Конфигурация
+  // ============================================================================
+  validators;
+  asyncValidators;
+  updateOn;
+  initialValue;
+  currentAbortController;
+  debounceMs;
+  validateDebounceTimer;
+  /**
+   * Pending debounced validation state
+   * Contains resolve function and AbortController for cancellation
+   */
+  pendingValidation;
+  /**
+   * Менеджер подписок для централизованного cleanup
+   * Использует SubscriptionManager вместо массива для управления подписками
+   */
+  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 = 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)
+    );
+  }
+  // ============================================================================
+  // Реализация абстрактных методов FormNode
+  // ============================================================================
+  getValue() {
+    return this._value.peek();
+  }
+  setValue(e, t) {
+    if (this._value.value = e, this._dirty.value = !0, t?.emitEvent === !1)
+      return;
+    const s = this.validators.length > 0 || this.asyncValidators.length > 0, i = this._errors.value.length > 0;
+    if (this.updateOn === "change") {
+      this.validate();
+      return;
+    }
+    i && s && this.validate();
+  }
+  patchValue(e) {
+    this.setValue(e);
+  }
+  /**
+   * Сбросить поле к указанному значению (или к initialValue)
+   *
+   * @param value - опциональное значение для сброса. Если не указано, используется initialValue
+   *
+   * @remarks
+   * Этот метод:
+   * - Устанавливает значение в value или initialValue
+   * - Очищает ошибки валидации
+   * - Сбрасывает touched/dirty флаги
+   * - Устанавливает статус в 'valid'
+   *
+   * Если вам нужно сбросить к исходному значению, используйте resetToInitial()
+   *
+   * @example
+   * ```typescript
+   * // Сброс к initialValue
+   * field.reset();
+   *
+   * // Сброс к новому значению
+   * field.reset('new value');
+   * ```
+   */
+  reset(e) {
+    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)
+   *
+   * @remarks
+   * Алиас для reset() без параметров, но более явный:
+   * - resetToInitial() - явно показывает намерение вернуться к начальному значению
+   * - reset() - может принимать новое значение
+   *
+   * Полезно когда:
+   * - Пользователь нажал "Cancel" - вернуть форму в исходное состояние
+   * - Форма была изменена через reset(newValue), но нужно вернуться к самому началу
+   * - Явное намерение показать "отмену всех изменений"
+   *
+   * @example
+   * ```typescript
+   * const field = new FieldNode({ value: 'initial', component: Input });
+   *
+   * field.setValue('changed');
+   * field.reset('temp value');
+   * console.log(field.value.value); // 'temp value'
+   *
+   * field.resetToInitial();
+   * console.log(field.value.value); // 'initial'
+   * ```
+   */
+  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 через AbortController.
+   * При быстром вводе только последняя валидация применяет результаты.
+   *
+   * @example
+   * ```typescript
+   * // Обычная валидация
+   * await field.validate();
+   *
+   * // С debounce
+   * await field.validate({ debounce: 300 });
+   * ```
+   */
+  async validate(e) {
+    const t = e?.debounce ?? this.debounceMs;
+    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;
+        }
+        this.pendingValidation = void 0;
+        const r = await this.validateImmediate(s);
+        i(r);
+      }, t), s.signal.addEventListener(
+        "abort",
+        () => {
+          this.validateDebounceTimer && (clearTimeout(this.validateDebounceTimer), this.validateDebounceTimer = void 0), i(!1);
+        },
+        { once: !0 }
+      );
+    });
+  }
+  /**
+   * Немедленная валидация без debounce
+   * @private
+   * @param providedController - AbortController from debounced validate()
+   * @remarks
+   * Защищена от race conditions через AbortController:
+   * - Отменяет предыдущую валидацию при запуске новой (if no controller provided)
+   * - Передаёт AbortSignal в async валидаторы для отмены операций (например, fetch)
+   * - Проверяет signal.aborted в ключевых точках
+   */
+  async validateImmediate(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 (s.aborted)
+      return !1;
+    if (i.length > 0) {
+      this._errors.value = i;
+      const n = i.some((o) => o.severity !== "warning");
+      if (this.statusMachine.setErrors(n), n)
+        return !1;
+    }
+    if (this.asyncValidators.length > 0) {
+      if (s.aborted)
+        return !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 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;
+    const t = e.some((s) => s.severity !== "warning");
+    this.statusMachine.setErrors(t);
+  }
+  clearErrors() {
+    this._errors.value = [], this.statusMachine.setErrors(!1);
+  }
+  // ============================================================================
+  // Protected hooks (Template Method pattern)
+  // ============================================================================
+  /**
+   * Hook: вызывается после markAsTouched()
+   *
+   * Для FieldNode: если updateOn === 'blur', запускаем валидацию
+   */
+  onMarkAsTouched() {
+    this.updateOn === "blur" && this.validate();
+  }
+  /**
+   * Hook: вызывается после disable()
+   *
+   * Для FieldNode: синхронизируем statusMachine и очищаем ошибки
+   */
+  onDisable() {
+    this.statusMachine.disable(), this._errors.value = [];
+  }
+  /**
+   * Hook: вызывается после enable()
+   *
+   * Для FieldNode: синхронизируем statusMachine и запускаем валидацию
+   */
+  onEnable() {
+    this.statusMachine.enable(this._errors.value.length > 0), this.validate();
+  }
+  /**
+   * Обновляет свойства компонента (например, опции для Select)
+   *
+   * @example
+   * ```typescript
+   * // Обновление опций для Select после загрузки справочников
+   * form.registrationAddress.city.updateComponentProps({
+   *   options: cities
+   * });
+   * ```
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  updateComponentProps(e) {
+    this._componentProps.value = {
+      ...this._componentProps.value,
+      ...e
+    };
+  }
+  /**
+   * Динамически изменяет триггер валидации (updateOn)
+   * Полезно для адаптивной валидации - например, переключиться на instant feedback после первого submit
+   *
+   * @param updateOn - новый триггер валидации: 'change' | 'blur' | 'submit'
+   *
+   * @example
+   * ```typescript
+   * // Сценарий 1: Instant feedback после submit
+   * const form = new GroupNode({
+   *   email: {
+   *     value: '',
+   *     component: Input,
+   *     updateOn: 'submit', // Изначально валидация только при submit
+   *     validators: [required, email]
+   *   }
+   * });
+   *
+   * await form.submit(async (values) => {
+   *   // После submit переключаем на instant feedback
+   *   form.email.setUpdateOn('change');
+   *   await api.save(values);
+   * });
+   *
+   * // Теперь валидация происходит при каждом изменении
+   *
+   * // Сценарий 2: Прогрессивное улучшение
+   * form.email.setUpdateOn('blur');  // Сначала только при blur
+   * // ... пользователь начинает вводить ...
+   * form.email.setUpdateOn('change'); // Переключаем на change для real-time feedback
+   * ```
+   */
+  setUpdateOn(e) {
+    this.updateOn = e;
+  }
+  getUpdateOn() {
+    return this.updateOn;
+  }
+  // ============================================================================
+  // Методы-помощники для реактивности (Фаза 1)
+  // ============================================================================
+  /**
+   * Подписка на изменения значения поля
+   * Автоматически отслеживает изменения через @preact/signals effect
+   *
+   * @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 = 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();
+    });
+  }
+  /**
+   * Вычисляемое значение из других полей
+   * Автоматически обновляет текущее поле при изменении источников
+   *
+   * @param sources - Массив ReadonlySignal для отслеживания
+   * @param computeFn - Функция вычисления нового значения
+   * @returns Функция отписки для cleanup
+   *
+   * @example
+   * ```typescript
+   * // Автоматический расчет первоначального взноса (20% от стоимости)
+   * const dispose = form.initialPayment.computeFrom(
+   *   [form.propertyValue.value],
+   *   (propertyValue) => {
+   *     return propertyValue ? propertyValue * 0.2 : null;
+   *   }
+   * );
+   *
+   * // Cleanup
+   * useEffect(() => dispose, []);
+   * ```
+   */
+  computeFrom(e, t) {
+    const s = m(() => {
+      const r = e.map((o) => o.value), n = t(...r);
+      this.setValue(n, { emitEvent: !1 });
+    }), i = A(w.ComputeFrom);
+    return this.disposers.add(i, s);
+  }
+  /**
+   * Очистить все ресурсы и таймеры
+   * Должен вызываться при unmount компонента
+   *
+   * @remarks
+   * Освобождает все ресурсы:
+   * - Отписывает все subscriptions через SubscriptionManager
+   * - Отменяет pending/running валидации через cancelPendingValidation()
+   *
+   * Использует try-finally для гарантированного cleanup даже при ошибках.
+   *
+   * @example
+   * ```typescript
+   * useEffect(() => {
+   *   return () => {
+   *     field.dispose();
+   *   };
+   * }, []);
+   * ```
+   */
+  dispose() {
+    try {
+      this.disposers.dispose();
+    } finally {
+      this.cancelPendingValidation();
+    }
+  }
+}
+class te {
+  form;
+  constructor(e) {
+    this.form = e;
+  }
+  /**
+   * Применить валидаторы к полям формы
+   *
+   * Этапы применения:
+   * 1. Разделение валидаторов на field и tree
+   * 2. Применение field валидаторов (sync/async)
+   * 3. Применение tree валидаторов (кросс-полевая валидация)
+   *
+   * @param validators Зарегистрированные валидаторы
+   */
+  async apply(e) {
+    const { validatorsByField: t, treeValidators: s } = this.groupValidators(e);
+    await this.applyFieldValidators(t), this.applyTreeValidators(s);
+  }
+  /**
+   * Группировка валидаторов по типам
+   *
+   * Разделяет валидаторы на:
+   * - Field validators (sync/async) - группируются по fieldPath
+   * - Tree validators - применяются ко всей форме
+   *
+   * @param validators Все зарегистрированные валидаторы
+   * @returns Сгруппированные валидаторы
+   */
+  groupValidators(e) {
+    const t = /* @__PURE__ */ new Map(), s = [];
+    for (const i of e)
+      if (i.type === "tree")
+        s.push(i);
+      else {
+        const r = t.get(i.fieldPath) || [];
+        r.push(i), t.set(i.fieldPath, r);
+      }
+    return { validatorsByField: t, treeValidators: s };
+  }
+  /**
+   * Применение field валидаторов к полям
+   *
+   * Для каждого поля:
+   * 1. Найти FieldNode по пути
+   * 2. Проверить условия (condition)
+   * 3. Выполнить sync/async валидаторы
+   * 4. Установить ошибки на поле
+   *
+   * @param validatorsByField Валидаторы, сгруппированные по полям
+   */
+  async applyFieldValidators(e) {
+    for (const [t, s] of e) {
+      const i = this.form.getFieldByPath(t);
+      if (!i) {
+        console.warn(`Field ${t} not found in GroupNode`);
+        continue;
+      }
+      if (!M(i) && !N(i)) {
+        process.env.NODE_ENV !== "production" && console.warn(`Validation can only run on FieldNode or ArrayNode, skipping ${t}`);
+        continue;
+      }
+      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 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}`,
+              V.LOG
+            );
+          }
+      r.length > 0 ? i.setErrors(r) : i.clearErrors();
+    }
+  }
+  /**
+   * Применение tree валидаторов (кросс-полевая валидация)
+   *
+   * Tree валидаторы имеют доступ ко всей форме через TreeValidationContext.
+   * Ошибки устанавливаются на targetField (если указано).
+   *
+   * @param treeValidators Список tree валидаторов
+   */
+  applyTreeValidators(e) {
+    for (const t of e) {
+      const s = new Y(this.form);
+      if (!(t.condition && !this.checkCondition(t.condition)))
+        try {
+          if (t.type !== "tree")
+            continue;
+          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 (i) {
+          S.handle(i, "ValidationApplicator: tree validator", V.LOG);
+        }
+    }
+  }
+  /**
+   * Проверка условия (condition) для валидатора
+   *
+   * Условие определяет, должен ли валидатор выполняться.
+   * Использует getFieldByPath для поддержки вложенных путей.
+   *
+   * @param condition Условие валидатора
+   * @returns true, если условие выполнено
+   */
+  checkCondition(e) {
+    const t = this.form.getFieldByPath(e.fieldPath);
+    if (!t)
+      return !1;
+    const s = t.value.value;
+    return e.conditionFn(s);
+  }
+}
+class se {
+  /**
+   * Парсит путь в массив сегментов
+   *
+   * Поддерживаемые форматы:
+   * - Простые пути: "name", "email"
+   * - Вложенные пути: "address.city", "user.profile.avatar"
+   * - Массивы: "items[0]", "items[0].name", "tags[1][0]"
+   * - Комбинации: "orders[0].items[1].price"
+   *
+   * @param path Путь к полю (строка с точками и квадратными скобками)
+   * @returns Массив сегментов пути
+   *
+   * @example
+   * ```typescript
+   * navigator.parsePath('email');
+   * // [{ key: 'email' }]
+   *
+   * navigator.parsePath('address.city');
+   * // [{ key: 'address' }, { key: 'city' }]
+   *
+   * navigator.parsePath('items[0].name');
+   * // [{ key: 'items', index: 0 }, { key: 'name' }]
+   * ```
+   */
+  parsePath(e) {
+    const t = [];
+    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 s && this.addSegment(t, s), t;
+  }
+  /**
+   * Добавляет сегмент в массив, обрабатывая массивы
+   * @private
+   */
+  addSegment(e, t) {
+    const s = t.match(/^(.+)\[(\d+)\]$/);
+    s ? e.push({
+      key: s[1],
+      index: parseInt(s[2], 10)
+    }) : e.push({ key: t });
+  }
+  /**
+   * Получает значение по пути из объекта
+   *
+   * Проходит по всем сегментам пути и возвращает конечное значение.
+   * Если путь не найден, возвращает undefined.
+   *
+   * @param obj Объект для навигации
+   * @param path Путь к значению
+   * @returns Значение или undefined, если путь не найден
+   *
+   * @example
+   * ```typescript
+   * const obj = {
+   *   email: 'test@mail.com',
+   *   address: { city: 'Moscow' },
+   *   items: [{ title: 'Item 1' }]
+   * };
+   *
+   * navigator.getValueByPath(obj, 'email');
+   * // 'test@mail.com'
+   *
+   * navigator.getValueByPath(obj, 'address.city');
+   * // 'Moscow'
+   *
+   * navigator.getValueByPath(obj, 'items[0].title');
+   * // 'Item 1'
+   *
+   * navigator.getValueByPath(obj, 'invalid.path');
+   * // undefined
+   * ```
+   */
+  getValueByPath(e, t) {
+    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 i;
+  }
+  /**
+   * Устанавливает значение по пути в объекте (мутирует объект)
+   *
+   * Создает промежуточные объекты, если они не существуют.
+   * Выбрасывает ошибку, если ожидается массив, но его нет.
+   *
+   * @param obj Объект для модификации
+   * @param path Путь к значению
+   * @param value Новое значение
+   *
+   * @throws {Error} Если ожидается массив по пути, но его нет
+   *
+   * @example
+   * ```typescript
+   * const obj = { address: { city: '' } };
+   * navigator.setValueByPath(obj, 'address.city', 'Moscow');
+   * // obj.address.city === 'Moscow'
+   *
+   * const obj2: UnknownRecord = {};
+   * navigator.setValueByPath(obj2, 'address.city', 'Moscow');
+   * // Создаст { address: { city: 'Moscow' } }
+   *
+   * const obj3 = { items: [{ title: 'Old' }] };
+   * navigator.setValueByPath(obj3, 'items[0].title', 'New');
+   * // obj3.items[0].title === 'New'
+   * ```
+   */
+  setValueByPath(e, t, s) {
+    const i = this.parsePath(t);
+    if (i.length === 0)
+      throw new Error("Cannot set value: empty path");
+    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
+        u == null && (r[l.key] = {}, u = r[l.key]), r = u;
+    }
+    const n = i[i.length - 1];
+    if (n.index !== void 0) {
+      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] = s;
+    } else
+      r[n.key] = s;
+  }
+  /**
+   * Получить значение из FormNode по пути
+   *
+   * Автоматически извлекает значение из FormNode (через .value.value).
+   * Используется в ValidationContext и BehaviorContext для единообразного
+   * доступа к значениям полей формы.
+   *
+   * @param form Корневой узел формы (обычно GroupNode)
+   * @param path Путь к полю
+   * @returns Значение поля или undefined, если путь не найден
+   *
+   * @example
+   * ```typescript
+   * const form = new GroupNode({
+   *   email: { value: 'test@mail.com', component: Input },
+   *   address: {
+   *     city: { value: 'Moscow', component: Input }
+   *   },
+   *   items: [{ title: { value: 'Item 1', component: Input } }]
+   * });
+   *
+   * navigator.getFormNodeValue(form, 'email');
+   * // 'test@mail.com'
+   *
+   * navigator.getFormNodeValue(form, 'address.city');
+   * // 'Moscow'
+   *
+   * navigator.getFormNodeValue(form, 'items[0].title');
+   * // 'Item 1'
+   *
+   * navigator.getFormNodeValue(form, 'invalid.path');
+   * // undefined
+   * ```
+   */
+  getFormNodeValue(e, t) {
+    const s = this.getNodeByPath(e, t);
+    if (s != null)
+      return this.isFormNode(s) ? s.value.value : s;
+  }
+  /**
+   * Type guard для проверки, является ли объект FormNode
+   *
+   * Проверяет наличие характерных свойств FormNode:
+   * - value (Signal)
+   * - value.value (значение Signal)
+   *
+   * @param obj Объект для проверки
+   * @returns true, если объект является FormNode
+   * @private
+   */
+  isFormNode(e) {
+    return e != null && typeof e == "object" && "value" in e && typeof e.value == "object" && e.value != null && "value" in e.value;
+  }
+  /**
+   * Получает узел формы по пути
+   *
+   * Навигирует по структуре FormNode (GroupNode/FieldNode/ArrayNode)
+   * и возвращает узел по указанному пути.
+   *
+   * Поддерживает:
+   * - Доступ к полям GroupNode через fields Map
+   * - Доступ к элементам ArrayNode через индекс
+   * - Proxy-доступ к полям (для обратной совместимости)
+   *
+   * @param form Корневой узел формы (обычно GroupNode)
+   * @param path Путь к узлу
+   * @returns Узел формы или null, если путь не найден
+   *
+   * @example
+   * ```typescript
+   * const form = new GroupNode({
+   *   email: { value: '', component: Input },
+   *   address: {
+   *     city: { value: '', component: Input }
+   *   },
+   *   items: [{ title: { value: '', component: Input } }]
+   * });
+   *
+   * const emailNode = navigator.getNodeByPath(form, 'email');
+   * // FieldNode
+   *
+   * const cityNode = navigator.getNodeByPath(form, 'address.city');
+   * // FieldNode
+   *
+   * const itemNode = navigator.getNodeByPath(form, 'items[0]');
+   * // GroupNode
+   *
+   * const titleNode = navigator.getNodeByPath(form, 'items[0].title');
+   * // FieldNode
+   *
+   * const invalidNode = navigator.getNodeByPath(form, 'invalid.path');
+   * // null
+   * ```
+   */
+  getNodeByPath(e, t) {
+    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 (i = n.fields.get(r.key), r.index === void 0) {
+          if (i == null) return null;
+          continue;
+        }
+      } else if (r.index !== void 0 && n.items) {
+        const o = n.items.value || n.items;
+        if (!Array.isArray(o) || (i = o[r.index], i == null)) return null;
+        continue;
+      } else if (r.index === void 0) {
+        if (i = n[r.key], i == null) return null;
+        continue;
+      }
+      if (i && r.index !== void 0 && i.items) {
+        const o = i.items.value || i.items;
+        if (!Array.isArray(o)) return null;
+        i = o[r.index];
+      } else if (i && r.index !== void 0 && !i.items)
+        return null;
+      if (i == null) return null;
+    }
+    return i;
+  }
+}
+function W(a) {
+  const { getChildren: e, ownErrors: t, disabled: s } = a, i = d(() => t.value.length > 0 ? !1 : e().every((h) => h.disabled.value || h.valid.value)), r = d(() => !i.value), n = d(() => e().some((h) => h.pending.value)), o = d(() => e().some((h) => h.touched.value)), l = d(() => e().some((h) => h.dirty.value)), u = d(() => {
+    const h = [...t.value];
+    for (const f of e())
+      h.push(...f.errors.value);
+    return h;
+  }), v = d(() => s?.value ? "disabled" : n.value ? "pending" : r.value ? "invalid" : "valid");
+  return {
+    valid: i,
+    invalid: r,
+    pending: n,
+    touched: o,
+    dirty: l,
+    errors: u,
+    status: v
+  };
+}
+function ie(a) {
+  return typeof a == "object" && a !== null && "getProxy" in a && typeof a.getProxy == "function";
+}
+function re(a, e) {
+  return new Proxy(a, {
+    get: (t, s) => {
+      if (s in t)
+        return t[s];
+      if (typeof s == "string" && e.has(s)) {
+        const i = e.get(s);
+        return i && ie(i) ? i.getProxy() : i;
+      }
+    },
+    set: (t, s, i) => typeof s == "string" && e.has(s) ? !1 : (t[s] = i, !0),
+    has: (t, s) => typeof s == "string" && e.has(s) ? !0 : s in t,
+    ownKeys: (t) => {
+      const s = Reflect.ownKeys(t), i = Array.from(e.keys());
+      return [.../* @__PURE__ */ new Set([...s, ...i])];
+    },
+    getOwnPropertyDescriptor: (t, s) => typeof s == "string" && e.has(s) ? { enumerable: !0, configurable: !0 } : Reflect.getOwnPropertyDescriptor(t, s)
+  });
+}
+class ae {
+  /**
+   * @param form - Форма для отправки
+   */
+  constructor(e) {
+    this.form = e;
+  }
+  /** Внутренний сигнал состояния отправки */
+  _submitting = g(!1);
+  /** Публичный read-only сигнал состояния отправки */
+  submitting = d(() => this._submitting.value);
+  /**
+   * Отправить форму
+   *
+   * Процесс:
+   * 1. Помечает все поля как touched (для отображения ошибок)
+   * 2. Валидирует форму
+   * 3. Если валидация успешна - вызывает onSubmit
+   * 4. Управляет состоянием submitting
+   *
+   * @param onSubmit - Callback для отправки данных
+   * @param options - Опции submit
+   * @returns Результат от onSubmit или null если валидация не пройдена
+   *
+   * @example
+   * ```typescript
+   * const result = await submitter.submit(async (values) => {
+   *   const response = await fetch('/api/form', {
+   *     method: 'POST',
+   *     body: JSON.stringify(values)
+   *   });
+   *   return response.json();
+   * });
+   *
+   * if (result === null) {
+   *   console.log('Форма не прошла валидацию');
+   * }
+   * ```
+   */
+  async submit(e, t) {
+    const { skipValidation: s = !1, skipTouch: i = !1 } = t || {};
+    if (i || this.form.markAsTouched(), !s && !await this.form.validate())
+      return null;
+    this._submitting.value = !0;
+    try {
+      return await e(this.form.getValue());
+    } finally {
+      this._submitting.value = !1;
+    }
+  }
+  /**
+   * Отправить форму с расширенным результатом
+   *
+   * В отличие от submit(), возвращает объект с информацией об успехе/ошибке
+   *
+   * @param onSubmit - Callback для отправки данных
+   * @param options - Опции submit
+   * @returns Объект SubmitResult с данными и статусом
+   *
+   * @example
+   * ```typescript
+   * const result = await submitter.submitWithResult(async (values) => {
+   *   return await api.saveForm(values);
+   * });
+   *
+   * if (result.success) {
+   *   console.log('Сохранено:', result.data);
+   * } else if (result.error) {
+   *   console.error('Ошибка:', result.error.message);
+   * } else {
+   *   console.log('Валидация не пройдена');
+   * }
+   * ```
+   */
+  async submitWithResult(e, t) {
+    const { skipValidation: s = !1, skipTouch: i = !1 } = t || {};
+    if (i || this.form.markAsTouched(), !s && !await this.form.validate())
+      return { success: !1, data: null };
+    this._submitting.value = !0;
+    try {
+      return { success: !0, data: await e(this.form.getValue()) };
+    } catch (r) {
+      return {
+        success: !1,
+        data: null,
+        error: r instanceof Error ? r : new Error(String(r))
+      };
+    } finally {
+      this._submitting.value = !1;
+    }
+  }
+  /**
+   * Проверить, идет ли отправка формы
+   */
+  isSubmitting() {
+    return this._submitting.value;
+  }
+}
+class k extends C {
+  // ============================================================================
+  // Приватные поля
+  // ============================================================================
+  id = crypto.randomUUID();
+  /**
+   * Коллекция полей формы (упрощённый Map вместо FieldRegistry)
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  _fields = /* @__PURE__ */ new Map();
+  /**
+   * Менеджер подписок для централизованного cleanup
+   */
+  disposers = new D();
+  /**
+   * Ссылка на Proxy-инстанс для использования в BehaviorContext
+   */
+  _proxyInstance;
+  /**
+   * Навигатор для работы с путями к полям
+   */
+  pathNavigator = new se();
+  /**
+   * Фабрика для создания узлов формы
+   */
+  nodeFactory = new ne();
+  /**
+   * Реестр валидаторов для этой формы
+   * Может быть инжектирован через config._validationRegistry для тестирования
+   */
+  validationRegistry;
+  /**
+   * Реестр behaviors для этой формы
+   * Может быть инжектирован через config._behaviorRegistry для тестирования
+   */
+  behaviorRegistry;
+  /**
+   * Аппликатор для применения валидаторов к форме
+   */
+  validationApplicator = new te(this);
+  // ============================================================================
+  // Приватные сигналы состояния (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;
+  invalid;
+  touched;
+  dirty;
+  pending;
+  errors;
+  status;
+  submitting;
+  constructor(e) {
+    super(), this.formSubmitter = new ae(this);
+    const t = "form" in e, s = t ? e : void 0, i = t ? e.form : e, r = t ? e.behavior : void 0, n = t ? e.validation : void 0;
+    this.validationRegistry = s?._validationRegistry ?? new K(), this.behaviorRegistry = s?._behaviorRegistry ?? new H();
+    for (const [l, u] of Object.entries(i)) {
+      const v = this.createNode(u);
+      this._fields.set(l, v);
+    }
+    this.value = 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._fields.forEach((t, s) => {
+      e[s] = t.getValue();
+    }), e;
+  }
+  setValue(e, t) {
+    for (const [s, i] of Object.entries(e)) {
+      const r = this._fields.get(s);
+      r && r.setValue(i, t);
+    }
+  }
+  patchValue(e) {
+    j(() => {
+      for (const [t, s] of Object.entries(e)) {
+        const i = this._fields.get(t);
+        i && s !== void 0 && i.setValue(s, { emitEvent: !1 });
+      }
+    });
+  }
+  /**
+   * Сбросить форму к указанным значениям (или к initialValues)
+   *
+   * @param value - опциональный объект со значениями для сброса
+   *
+   * @remarks
+   * Рекурсивно вызывает reset() для всех полей формы
+   *
+   * @example
+   * ```typescript
+   * // Сброс к initialValues
+   * form.reset();
+   *
+   * // Сброс к новым значениям
+   * form.reset({ email: 'new@mail.com', password: '' });
+   * ```
+   */
+  reset(e) {
+    this._fields.forEach((t, s) => {
+      const i = e?.[s];
+      t.reset(i);
+    });
+  }
+  /**
+   * Сбросить форму к исходным значениям (initialValues)
+   */
+  resetToInitial() {
+    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._fields.values()).map((t) => t.validate()));
+    const e = this.validationRegistry.getValidators();
+    return e && e.length > 0 && await this.applyContextualValidators(e), Array.from(this._fields.values()).every(
+      (t) => t.valid.value || t.disabled.value
+    );
+  }
+  /**
+   * Установить form-level validation errors
+   */
+  setErrors(e) {
+    this._formErrors.value = e;
+  }
+  /**
+   * Очистить все errors (form-level + field-level)
+   */
+  clearErrors() {
+    this._formErrors.value = [], this._fields.forEach((e) => e.clearErrors());
+  }
+  /**
+   * Получить поле по ключу
+   */
+  getField(e) {
+    return this._fields.get(e);
+  }
+  /**
+   * Получить Map всех полей формы (для совместимости)
+   */
+  get fields() {
+    return this._fields;
+  }
+  /**
+   * Получить Proxy-инстанс для прямого доступа к полям
+   *
+   * Proxy позволяет обращаться к полям формы напрямую через точечную нотацию:
+   * - form.email вместо form.fields.get('email')
+   * - form.address.city вместо form.fields.get('address').fields.get('city')
+   *
+   * Используется в:
+   * - BehaviorApplicator для доступа к полям в behavior functions
+   * - ValidationApplicator для доступа к форме в tree validators
+   *
+   * @returns Proxy-инстанс с типобезопасным доступом к полям или сама форма, если proxy не доступен
+   *
+   * @example
+   * ```typescript
+   * const form = new GroupNode({
+   *   controls: {
+   *     email: new FieldNode({ value: '' }),
+   *     name: new FieldNode({ value: '' })
+   *   }
+   * });
+   *
+   * const proxy = form.getProxy();
+   * console.log(proxy.email.value); // Прямой доступ к полю
+   * ```
+   */
+  getProxy() {
+    return this._proxyInstance || (this._proxyInstance = this.buildProxy()), this._proxyInstance;
+  }
+  /**
+   * Получить все поля формы как итератор
+   */
+  getAllFields() {
+    return this._fields.values();
+  }
+  // ============================================================================
+  // Protected hooks (Template Method pattern)
+  // ============================================================================
+  onMarkAsTouched() {
+    this._fields.forEach((e) => e.markAsTouched());
+  }
+  onMarkAsUntouched() {
+    this._fields.forEach((e) => e.markAsUntouched());
+  }
+  onMarkAsDirty() {
+    this._fields.forEach((e) => e.markAsDirty());
+  }
+  onMarkAsPristine() {
+    this._fields.forEach((e) => e.markAsPristine());
+  }
+  // ============================================================================
+  // Дополнительные методы (из FormStore)
+  // ============================================================================
+  /**
+   * Отправить форму
+   *
+   * @param onSubmit - Callback для отправки данных
+   * @param options - Опции submit (skipValidation, skipTouch)
+   * @returns Результат от onSubmit или null если валидация не пройдена
+   */
+  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 к форме
+   *
+   * Использует локальный реестр валидаторов (this.validationRegistry)
+   * вместо глобального Singleton для изоляции форм друг от друга.
+   */
+  applyValidationSchema(e) {
+    this.validationRegistry.beginRegistration();
+    try {
+      const t = I();
+      e(t);
+      const s = this.getProxy();
+      this.validationRegistry.endRegistration(s);
+    } catch (t) {
+      throw console.error("Error applying validation schema:", t), t;
+    }
+  }
+  /**
+   * Применить behavior schema к форме
+   * @returns Функция cleanup для отписки от всех behaviors
+   */
+  applyBehaviorSchema(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;
+    }
+  }
+  /**
+   * Получить вложенное поле по пути
+   *
+   * Поддерживаемые форматы путей:
+   * - Simple: "email" - получить поле верхнего уровня
+   * - Nested: "address.city" - получить вложенное поле
+   * - Array index: "items[0]" - получить элемент массива по индексу
+   * - Combined: "items[0].name" - получить поле элемента массива
+   *
+   * @param path - Путь к полю
+   * @returns FormNode если найдено, undefined если путь не существует
+   *
+   * @example
+   * ```typescript
+   * const form = new GroupNode({
+   *   email: { value: '', component: Input },
+   *   address: {
+   *     city: { value: '', component: Input }
+   *   },
+   *   items: [{ name: { value: '', component: Input } }]
+   * });
+   *
+   * form.getFieldByPath('email');           // FieldNode
+   * form.getFieldByPath('address.city');    // FieldNode
+   * form.getFieldByPath('items[0]');        // GroupNode
+   * form.getFieldByPath('items[0].name');   // FieldNode
+   * form.getFieldByPath('invalid.path');    // undefined
+   * ```
+   */
+  getFieldByPath(e) {
+    if (e.startsWith(".") || e.endsWith("."))
+      return;
+    const t = this.pathNavigator.parsePath(e);
+    if (t.length === 0)
+      return;
+    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 s;
+  }
+  /**
+   * Применить contextual валидаторы к полям
+   *
+   * ✅ РЕФАКТОРИНГ: Делегирование ValidationApplicator (SRP)
+   *
+   * Логика применения валидаторов извлечена в ValidationApplicator для:
+   * - Соблюдения Single Responsibility Principle
+   * - Уменьшения размера GroupNode (~120 строк)
+   * - Улучшения тестируемости
+   *
+   * @param validators Зарегистрированные валидаторы
+   */
+  async applyContextualValidators(e) {
+    await this.validationApplicator.apply(e);
+  }
+  // ============================================================================
+  // Private методы для создания узлов
+  // ============================================================================
+  /**
+   * Создать узел на основе конфигурации
+   *
+   * ✅ РЕФАКТОРИНГ: Полное делегирование NodeFactory
+   *
+   * NodeFactory теперь обрабатывает:
+   * - Массивы [schema, ...items]
+   * - FieldConfig
+   * - GroupConfig
+   * - ArrayConfig
+   *
+   * @param config Конфигурация узла
+   * @returns Созданный узел формы
+   * @private
+   */
+  createNode(e) {
+    return this.nodeFactory.createNode(e);
+  }
+  // ============================================================================
+  // Методы-помощники для реактивности (Фаза 1)
+  // ============================================================================
+  /**
+   * Связывает два поля: при изменении source автоматически обновляется target
+   */
+  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);
+  }
+  /**
+   * Подписка на изменения вложенного поля по строковому пути
+   * Поддерживает вложенные пути типа "address.city"
+   *
+   * @param fieldPath - Строковый путь к полю (например, "address.city")
+   * @param callback - Функция, вызываемая при изменении поля
+   * @returns Функция отписки для cleanup
+   *
+   * @example
+   * ```typescript
+   * // Подписка на изменение страны для загрузки городов
+   * const dispose = form.watchField(
+   *   'registrationAddress.country',
+   *   async (countryCode) => {
+   *     if (countryCode) {
+   *       const cities = await fetchCitiesByCountry(countryCode);
+   *       form.registrationAddress.city.updateComponentProps({
+   *         options: cities
+   *       });
+   *     }
+   *   }
+   * );
+   *
+   * // Cleanup
+   * useEffect(() => dispose, []);
+   * ```
+   */
+  watchField(e, t) {
+    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);
+    }), r = A(w.WatchField);
+    return this.disposers.add(r, i);
+  }
+  /**
+   * Hook: вызывается после disable()
+   */
+  onDisable() {
+    this._disabled.value = !0, this._fields.forEach((e) => e.disable());
+  }
+  /**
+   * Hook: вызывается после enable()
+   */
+  onEnable() {
+    this._disabled.value = !1, this._fields.forEach((e) => e.enable());
+  }
+  /**
+   * Очистить все ресурсы узла
+   */
+  dispose() {
+    this.disposers.dispose(), this._fields.forEach((e) => {
+      "dispose" in e && typeof e.dispose == "function" && e.dispose();
+    });
+  }
+}
+class L extends C {
+  // ============================================================================
+  // Приватные поля
+  // ============================================================================
+  items;
+  itemSchema;
+  initialItems;
+  /**
+   * Менеджер подписок для централизованного cleanup
+   * Использует SubscriptionManager вместо массива для управления подписками
+   */
+  disposers = new D();
+  /** Array-level validation errors (e.g., "минимум 1 элемент") */
+  _arrayErrors = g([]);
+  // ============================================================================
+  // Приватные поля для сохранения схем
+  // ============================================================================
+  validationSchemaFn;
+  behaviorSchemaFn;
+  // ============================================================================
+  // Публичные computed signals
+  // ============================================================================
+  value;
+  valid;
+  invalid;
+  touched;
+  dirty;
+  pending;
+  errors;
+  status;
+  length;
+  // ============================================================================
+  // Конструктор
+  // ============================================================================
+  constructor(e, t = []) {
+    super(), this.itemSchema = e, this.initialItems = t, this.items = g([]);
+    for (const i of t)
+      this.push(i);
+    this.length = d(() => this.items.value.length), this.value = d(() => this.items.value.map((i) => i.value.value));
+    const s = W({
+      getChildren: () => this.items.value,
+      ownErrors: this._arrayErrors
+    });
+    this.valid = s.valid, this.invalid = s.invalid, this.pending = s.pending, this.touched = s.touched, this.dirty = s.dirty, this.errors = s.errors, this.status = s.status;
+  }
+  // ============================================================================
+  // CRUD операции
+  // ============================================================================
+  /**
+   * Добавить элемент в конец массива
+   * @param initialValue - Начальные значения для нового элемента
+   */
+  push(e) {
+    const t = this.createItem(e);
+    this.items.value = [...this.items.value, t];
+  }
+  /**
+   * Удалить элемент по индексу
+   * @param index - Индекс элемента для удаления
+   *
+   * @remarks
+   * Вызывает dispose() на удаляемом элементе для очистки подписок
+   */
+  removeAt(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();
+  }
+  /**
+   * Вставить элемент в массив
+   * @param index - Индекс для вставки
+   * @param initialValue - Начальные значения для нового элемента
+   */
+  insert(e, t) {
+    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 s = this.createItem(t), i = [...this.items.value];
+    i.splice(e, 0, s), this.items.value = i;
+  }
+  /**
+   * Удалить все элементы массива
+   *
+   * @remarks
+   * Вызывает dispose() на всех элементах для очистки подписок
+   */
+  clear() {
+    const e = [...this.items.value];
+    this.items.value = [], e.forEach((t) => {
+      "dispose" in t && typeof t.dispose == "function" && t.dispose();
+    });
+  }
+  /**
+   * Получить элемент по индексу
+   * @param index - Индекс элемента
+   * @returns Типизированный GroupNode proxy или undefined если индекс вне границ
+   */
+  at(e) {
+    const t = this.items.value[e];
+    if (t)
+      return t.getProxy();
+  }
+  // ============================================================================
+  // Реализация абстрактных методов
+  // ============================================================================
+  getValue() {
+    return this.items.value.map((e) => e.getValue());
+  }
+  setValue(e, t) {
+    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, s) => {
+      this.items.value[s] && t !== void 0 && this.items.value[s].patchValue(t);
+    });
+  }
+  /**
+   * Сбросить массив к указанным значениям (или очистить)
+   *
+   * @param values - опциональный массив значений для сброса
+   *
+   * @remarks
+   * Очищает текущий массив и заполняет новыми элементами
+   *
+   * @example
+   * ```typescript
+   * // Очистить массив
+   * arrayNode.reset();
+   *
+   * // Сбросить к новым значениям
+   * arrayNode.reset([{ name: 'Item 1' }, { name: 'Item 2' }]);
+   * ```
+   */
+  reset(e) {
+    this._arrayErrors.value = [], this.clear(), e && e.forEach((t) => this.push(t));
+  }
+  /**
+   * Сбросить массив к исходным значениям (initialItems)
+   *
+   * @remarks
+   * Восстанавливает массив в состояние, которое было при создании ArrayNode.
+   * Более явный способ сброса к начальным значениям по сравнению с reset()
+   *
+   * Полезно когда:
+   * - Пользователь нажал "Cancel" - вернуть массив к исходным элементам
+   * - Массив был изменен через reset(newValues), но нужно вернуться к началу
+   * - Явное намерение показать "отмена всех изменений"
+   *
+   * @example
+   * ```typescript
+   * const arrayNode = new ArrayNode(
+   *   { name: { value: '', component: Input } },
+   *   [{ name: 'Initial 1' }, { name: 'Initial 2' }]
+   * );
+   *
+   * arrayNode.push({ name: 'New Item' });
+   * arrayNode.reset([{ name: 'Temp' }]);
+   * console.log(arrayNode.length.value); // 1
+   *
+   * arrayNode.resetToInitial();
+   * console.log(arrayNode.length.value); // 2
+   * console.log(arrayNode.at(0)?.name.value.value); // 'Initial 1'
+   * ```
+   */
+  resetToInitial() {
+    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._arrayErrors.value = [], this.items.value.forEach((e) => e.clearErrors());
+  }
+  // ============================================================================
+  // Protected hooks (Template Method pattern)
+  // ============================================================================
+  /**
+   * Hook: вызывается после markAsTouched()
+   *
+   * Для ArrayNode: рекурсивно помечаем все элементы массива как touched
+   */
+  onMarkAsTouched() {
+    this.items.value.forEach((e) => e.markAsTouched());
+  }
+  /**
+   * Hook: вызывается после markAsUntouched()
+   *
+   * Для ArrayNode: рекурсивно помечаем все элементы массива как untouched
+   */
+  onMarkAsUntouched() {
+    this.items.value.forEach((e) => e.markAsUntouched());
+  }
+  /**
+   * Hook: вызывается после markAsDirty()
+   *
+   * Для ArrayNode: рекурсивно помечаем все элементы массива как dirty
+   */
+  onMarkAsDirty() {
+    this.items.value.forEach((e) => e.markAsDirty());
+  }
+  /**
+   * Hook: вызывается после markAsPristine()
+   *
+   * Для ArrayNode: рекурсивно помечаем все элементы массива как pristine
+   */
+  onMarkAsPristine() {
+    this.items.value.forEach((e) => e.markAsPristine());
+  }
+  // ============================================================================
+  // Итерация
+  // ============================================================================
+  /**
+   * Итерировать по элементам массива
+   * @param callback - Функция, вызываемая для каждого элемента с типизированным GroupNode proxy
+   */
+  forEach(e) {
+    this.items.value.forEach((t, s) => {
+      const i = t.getProxy();
+      e(i, s);
+    });
+  }
+  /**
+   * Маппинг элементов массива
+   * @param callback - Функция преобразования с типизированным GroupNode proxy
+   * @returns Новый массив результатов
+   */
+  map(e) {
+    return this.items.value.map((t, s) => {
+      const i = t.getProxy();
+      return e(i, s);
+    });
+  }
+  // ============================================================================
+  // Private методы
+  // ============================================================================
+  /**
+   * Создать новый элемент массива на основе схемы
+   * @param initialValue - Начальные значения
+   */
+  createItem(e) {
+    if (this.isGroupSchema(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(
+      "ArrayNode поддерживает только GroupNode элементы. Для массива примитивов используйте обычное поле с типом массива."
+    );
+  }
+  /**
+   * Проверить, является ли схема групповой (объект полей)
+   * @param schema - Схема для проверки
+   */
+  isGroupSchema(e) {
+    return typeof e == "object" && e !== null && !("component" in e) && !Array.isArray(e);
+  }
+  // ============================================================================
+  // Validation Schema
+  // ============================================================================
+  /**
+   * Применить validation schema ко всем элементам массива
+   *
+   * Validation schema будет применена к:
+   * - Всем существующим элементам
+   * - Всем новым элементам, добавляемым через push/insert
+   *
+   * @param schemaFn - Функция валидации для элемента массива
+   *
+   * @example
+   * ```typescript
+   * import { propertyValidation } from './validation/property-validation';
+   *
+   * form.properties.applyValidationSchema(propertyValidation);
+   * ```
+   */
+  applyValidationSchema(e) {
+    this.validationSchemaFn = e, this.items.value.forEach((t) => {
+      "applyValidationSchema" in t && typeof t.applyValidationSchema == "function" && t.applyValidationSchema(e);
+    });
+  }
+  /**
+   * Применить behavior schema ко всем элементам ArrayNode
+   *
+   * Автоматически применяется к новым элементам при push/insert.
+   *
+   * @param schemaFn - Behavior schema функция
+   *
+   * @example
+   * ```typescript
+   * import { addressBehavior } from './behaviors/address-behavior';
+   *
+   * form.addresses.applyBehaviorSchema(addressBehavior);
+   * ```
+   */
+  applyBehaviorSchema(e) {
+    this.behaviorSchemaFn = e, this.items.value.forEach((t) => {
+      "applyBehaviorSchema" in t && typeof t.applyBehaviorSchema == "function" && t.applyBehaviorSchema(e);
+    });
+  }
+  // ============================================================================
+  // Методы-помощники для реактивности (Фаза 1)
+  // ============================================================================
+  /**
+   * Подписка на изменения конкретного поля во всех элементах массива
+   * Срабатывает при изменении значения поля в любом элементе
+   *
+   * @param fieldKey - Ключ поля для отслеживания
+   * @param callback - Функция, вызываемая при изменении, получает массив всех значений и индекс измененного элемента
+   * @returns Функция отписки для cleanup
+   *
+   * @example
+   * ```typescript
+   * // Автоматический пересчет общей стоимости при изменении цен
+   * const dispose = form.existingLoans.watchItems(
+   *   'remainingAmount',
+   *   (amounts) => {
+   *     const totalDebt = amounts.reduce((sum, amount) => sum + (amount || 0), 0);
+   *     form.totalDebt.setValue(totalDebt);
+   *   }
+   * );
+   *
+   * // При изменении любого remainingAmount → пересчитается totalDebt
+   * form.existingLoans.at(0)?.remainingAmount.setValue(500000);
+   *
+   * // Cleanup
+   * useEffect(() => dispose, []);
+   * ```
+   */
+  watchItems(e, t) {
+    const s = m(() => {
+      const r = this.items.value.map((n) => {
+        if (n instanceof k)
+          return n.getFieldByPath(e)?.value.value;
+      });
+      t(r);
+    }), i = A(w.WatchItems);
+    return this.disposers.add(i, s);
+  }
+  /**
+   * Подписка на изменение длины массива
+   * Срабатывает при добавлении/удалении элементов
+   *
+   * @param callback - Функция, вызываемая при изменении длины, получает новую длину
+   * @returns Функция отписки для cleanup
+   *
+   * @example
+   * ```typescript
+   * // Обновление счетчика элементов в UI
+   * const dispose = form.properties.watchLength((length) => {
+   *   console.log(`Количество объектов недвижимости: ${length}`);
+   *   form.propertyCount.setValue(length);
+   * });
+   *
+   * form.properties.push({ title: 'Квартира', value: 5000000 });
+   * // Выведет: "Количество объектов недвижимости: 1"
+   *
+   * // Cleanup
+   * useEffect(() => dispose, []);
+   * ```
+   */
+  watchLength(e) {
+    const t = m(() => {
+      const i = this.length.value;
+      e(i);
+    }), s = A(w.WatchLength);
+    return this.disposers.add(s, t);
+  }
+  /**
+   * Очистить все ресурсы узла
+   * Рекурсивно очищает все subscriptions и элементы массива
+   *
+   * @example
+   * ```typescript
+   * useEffect(() => {
+   *   return () => {
+   *     arrayNode.dispose();
+   *   };
+   * }, []);
+   * ```
+   */
+  dispose() {
+    this.disposers.dispose(), this.items.value.forEach((e) => {
+      "dispose" in e && typeof e.dispose == "function" && e.dispose();
+    });
+  }
+  /**
+   * Hook: вызывается после disable()
+   *
+   * Для ArrayNode: рекурсивно отключаем все элементы массива
+   *
+   * @example
+   * ```typescript
+   * // Отключить весь массив полей
+   * form.items.disable();
+   *
+   * // Все элементы становятся disabled
+   * form.items.forEach(item => {
+   *   console.log(item.status.value); // 'disabled'
+   * });
+   * ```
+   */
+  onDisable() {
+    this.items.value.forEach((e) => {
+      e.disable();
+    });
+  }
+  /**
+   * Hook: вызывается после enable()
+   *
+   * Для ArrayNode: рекурсивно включаем все элементы массива
+   *
+   * @example
+   * ```typescript
+   * // Включить весь массив полей
+   * form.items.enable();
+   *
+   * // Все элементы становятся enabled
+   * form.items.forEach(item => {
+   *   console.log(item.status.value); // 'valid' или 'invalid'
+   * });
+   * ```
+   */
+  onEnable() {
+    this.items.value.forEach((e) => {
+      e.enable();
+    });
+  }
+}
+class ne {
+  /**
+   * Создает узел формы на основе конфигурации
+   *
+   * ✅ ОБНОВЛЕНО: Теперь поддерживает массивы напрямую
+   *
+   * Автоматически определяет тип узла:
+   * - FieldNode: имеет value и component
+   * - ArrayNode: массив [schema, ...items] или { schema, initialItems }
+   * - GroupNode: объект без value, component, schema
+   *
+   * @param config Конфигурация узла
+   * @returns Экземпляр FieldNode, GroupNode или ArrayNode
+   * @throws Error если конфиг не соответствует ни одному типу
+   *
+   * @example
+   * ```typescript
+   * const factory = new NodeFactory();
+   *
+   * // FieldNode
+   * const field = factory.createNode({
+   *   value: 'test@mail.com',
+   *   component: Input,
+   *   validators: [required, email]
+   * });
+   *
+   * // GroupNode
+   * const group = factory.createNode({
+   *   email: { value: '', component: Input },
+   *   password: { value: '', component: Input }
+   * });
+   *
+   * // ArrayNode (объект)
+   * const array = factory.createNode({
+   *   schema: { title: { value: '', component: Input } },
+   *   initialItems: [{ title: 'Item 1' }]
+   * });
+   *
+   * // ArrayNode (массив) - новый формат
+   * const array2 = factory.createNode([
+   *   { title: { value: '', component: Input } }, // schema
+   *   { title: 'Item 1' }, // initial item 1
+   *   { title: 'Item 2' }  // initial item 2
+   * ]);
+   * ```
+   */
+  createNode(e) {
+    if (Array.isArray(e) && e.length >= 1)
+      return this.createArrayNodeFromArray(e);
+    if (this.isFieldConfig(e))
+      return new ee(e);
+    if (this.isArrayConfig(e)) {
+      const t = e;
+      return new L(
+        t.schema,
+        t.initialItems
+      );
+    }
+    if (this.isGroupConfig(e))
+      return new k(e);
+    throw new Error(
+      `NodeFactory: Unknown node config. Expected FieldConfig, GroupConfig, or ArrayConfig, but got: ${JSON.stringify(
+        e
+      )}`
+    );
+  }
+  /**
+   * Создать ArrayNode из массива [schema, ...initialItems]
+   *
+   * ✅ НОВОЕ: Извлечено из GroupNode для централизации логики
+   *
+   * Формат: [itemSchema, ...initialItems]
+   * - Первый элемент - схема элемента массива
+   * - Остальные элементы - начальные значения
+   *
+   * @param config Массив с схемой и начальными элементами
+   * @returns ArrayNode
+   *
+   * @example
+   * ```typescript
+   * const factory = new NodeFactory();
+   *
+   * // Массив с начальными элементами
+   * const array = factory.createArrayNodeFromArray([
+   *   { title: { value: '', component: Input } }, // schema
+   *   { title: 'Item 1' }, // initial value
+   *   { title: 'Item 2' }  // initial value
+   * ]);
+   * ```
+   * @private
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  createArrayNodeFromArray(e) {
+    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);
+  }
+  /**
+   * Извлечь значения из схемы (рекурсивно)
+   *
+   * ✅ НОВОЕ: Извлечено из GroupNode для централизации логики
+   *
+   * Преобразует схему формы в объект со значениями:
+   * - `{ name: { value: 'John', component: Input } } → { name: 'John' }`
+   * - Поддерживает вложенные группы
+   * - Поддерживает массивы
+   *
+   * @param schema Схема формы
+   * @returns Объект со значениями полей
+   *
+   * @example
+   * ```typescript
+   * const factory = new NodeFactory();
+   *
+   * const schema = {
+   *   name: { value: 'John', component: Input },
+   *   age: { value: 30, component: Input },
+   *   address: {
+   *     city: { value: 'Moscow', component: Input }
+   *   }
+   * };
+   *
+   * factory.extractValues(schema);
+   * // { name: 'John', age: 30, address: { city: 'Moscow' } }
+   * ```
+   */
+  extractValues(e) {
+    if (this.isFieldConfig(e))
+      return e.value;
+    if (Array.isArray(e))
+      return e.map((t) => this.extractValues(t));
+    if (this.isGroupConfig(e)) {
+      const t = {};
+      for (const [s, i] of Object.entries(e))
+        t[s] = this.extractValues(i);
+      return t;
+    }
+    return e;
+  }
+  /**
+   * Проверяет, является ли конфиг конфигурацией поля (FieldConfig)
+   *
+   * FieldConfig имеет обязательные свойства:
+   * - value: начальное значение поля
+   * - component: React-компонент для отображения
+   *
+   * @param config Проверяемая конфигурация
+   * @returns true если config является FieldConfig
+   *
+   * @example
+   * ```typescript
+   * const factory = new NodeFactory();
+   *
+   * factory.isFieldConfig({ value: '', component: Input }); // true
+   * factory.isFieldConfig({ email: { value: '' } }); // false
+   * factory.isFieldConfig(null); // false
+   * ```
+   */
+  isFieldConfig(e) {
+    return e != null && typeof e == "object" && "value" in e && "component" in e;
+  }
+  /**
+   * Проверяет, является ли конфиг конфигурацией массива (ArrayConfig)
+   *
+   * ArrayConfig имеет обязательное свойство:
+   * - schema: схема для элементов массива
+   *
+   * И НЕ имеет:
+   * - value (отличие от FieldConfig)
+   *
+   * @param config Проверяемая конфигурация
+   * @returns true если config является ArrayConfig
+   *
+   * @example
+   * ```typescript
+   * const factory = new NodeFactory();
+   *
+   * factory.isArrayConfig({ schema: {}, initialItems: [] }); // true
+   * factory.isArrayConfig({ value: '', component: Input }); // false
+   * factory.isArrayConfig({ email: { value: '' } }); // false
+   * ```
+   */
+  isArrayConfig(e) {
+    return e != null && typeof e == "object" && "schema" in e && !("value" in e);
+  }
+  /**
+   * Проверяет, является ли конфиг конфигурацией группы (GroupConfig)
+   *
+   * GroupConfig - это объект, который:
+   * - НЕ является FieldConfig (нет value/component)
+   * - НЕ является ArrayConfig (нет schema)
+   * - Содержит вложенные конфиги полей/групп/массивов
+   *
+   * @param config Проверяемая конфигурация
+   * @returns true если config является GroupConfig
+   *
+   * @example
+   * ```typescript
+   * const factory = new NodeFactory();
+   *
+   * factory.isGroupConfig({
+   *   email: { value: '', component: Input },
+   *   password: { value: '', component: Input }
+   * }); // true
+   *
+   * factory.isGroupConfig({ value: '', component: Input }); // false
+   * factory.isGroupConfig({ schema: {} }); // false
+   * factory.isGroupConfig(null); // false
+   * ```
+   */
+  isGroupConfig(e) {
+    return e != null && typeof e == "object" && !this.isFieldConfig(e) && !this.isArrayConfig(e);
+  }
+}
+function ge(a) {
+  return new k(a).getProxy();
+}
+class be {
+  /**
+   * @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 callback - Функция обработки события
+   * @returns Функция отписки
+   *
+   * @example
+   * ```typescript
+   * const unsubscribe = observer.subscribe((event) => {
+   *   // Отправить событие в analytics
+   *   analytics.track('form_change', event);
+   * });
+   * ```
+   */
+  subscribe(e) {
+    return this.listeners.add(e), () => this.listeners.delete(e);
+  }
+  /**
+   * Включить трассировку формы
+   *
+   * Подписывается на изменения основных сигналов формы
+   * и вызывает listeners при каждом изменении
+   *
+   * @returns Функция для отключения трассировки
+   *
+   * @example
+   * ```typescript
+   * const dispose = observer.enableTracing();
+   *
+   * // Позже, для отключения
+   * dispose();
+   * ```
+   */
+  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 = [];
+    };
+  }
+  /**
+   * Наблюдать за конкретным полем
+   *
+   * @param path - Путь к полю
+   * @returns Функция для отключения наблюдения
+   *
+   * @example
+   * ```typescript
+   * // Наблюдать за полем email
+   * const dispose = observer.watchField('email');
+   * ```
+   */
+  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());
+  }
+  /**
+   * Отправить событие всем listeners
+   */
+  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 {
+      }
+    }));
+  }
+  /**
+   * Проверить, нужно ли отслеживать тип события
+   */
+  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();
+  }
+}
+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;
+}
+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);
+      }
+      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 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;
+}
+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 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;
+        }
+        n();
+      });
+    },
+    [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;
+        }
+      } 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 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 Ee(a) {
+  const e = a && "length" in a && "map" in a;
+  return a ? e ? ce(a) : de(a) : {
+    value: [],
+    length: 0,
+    pending: !1,
+    errors: [],
+    valid: !0,
+    invalid: !1,
+    touched: !1,
+    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 {
+  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
+};