@reformer/core 1.1.0 → 2.0.0-beta.3

package/dist/node-factory-D7DOnSSN.js

@@ -1,3200 +0,0 @@
-import { d, w as l, E as c, c as w, V as A, B as F } from "./create-field-path-CdPF3lIK.js";
-import { v4 as k } from "uuid";
-class g {
-  // ============================================================================
-  // Protected состояние (для Template Method паттерна)
-  // ============================================================================
-  /**
-   * Пользователь взаимодействовал с узлом (touched)
-   * Protected: наследники могут читать/изменять через методы
-   */
-  _touched = d(!1);
-  /**
-   * Значение узла было изменено (dirty)
-   * Protected: наследники могут читать/изменять через методы
-   */
-  _dirty = d(!1);
-  /**
-   * Текущий статус узла
-   * Protected: наследники могут читать/изменять через методы
-   */
-  _status = d("valid");
-  // ============================================================================
-  // Публичные computed signals (readonly для внешнего мира)
-  // ============================================================================
-  /**
-   * Пользователь взаимодействовал с узлом (touched)
-   * Computed из _touched для предоставления readonly интерфейса
-   */
-  touched = l(() => this._touched.value);
-  /**
-   * Пользователь не взаимодействовал с узлом (untouched)
-   */
-  untouched = l(() => !this._touched.value);
-  /**
-   * Значение узла было изменено (dirty)
-   * Computed из _dirty для предоставления readonly интерфейса
-   */
-  dirty = l(() => this._dirty.value);
-  /**
-   * Значение узла не было изменено (pristine)
-   */
-  pristine = l(() => !this._dirty.value);
-  /**
-   * Текущий статус узла
-   * Computed из _status для предоставления readonly интерфейса
-   */
-  status = l(() => this._status.value);
-  /**
-   * Узел отключен (disabled)
-   */
-  disabled = l(() => this._status.value === "disabled");
-  /**
-   * Узел включен (enabled)
-   */
-  enabled = l(() => 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(t) {
-    const e = this.errors.value;
-    return t ? e.filter((i) => {
-      if (t.code !== void 0 && !(Array.isArray(t.code) ? t.code : [t.code]).includes(i.code) || t.message !== void 0 && !i.message.toLowerCase().includes(t.message.toLowerCase()))
-        return !1;
-      if (t.params !== void 0) {
-        if (!i.params)
-          return !1;
-        for (const [s, a] of Object.entries(t.params))
-          if (i.params[s] !== a)
-            return !1;
-      }
-      return !(t.predicate !== void 0 && !t.predicate(i));
-    }) : e;
-  }
-  // ============================================================================
-  // Методы управления состоянием (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 _ {
-  /**
-   * Хранилище подписок
-   * Ключ: уникальный идентификатор подписки
-   * Значение: функция отписки (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(t, e) {
-    return this.subscriptions.has(t) && (process.env.NODE_ENV !== "production" && console.warn(`[SubscriptionManager] Subscription "${t}" already exists, replacing`), this.subscriptions.get(t)?.()), this.subscriptions.set(t, e), () => this.remove(t);
-  }
-  /**
-   * Удаляет подписку по ключу
-   *
-   * Вызывает функцию отписки и удаляет подписку из хранилища.
-   * Если подписка с таким ключом не найдена, ничего не делает.
-   *
-   * @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(t) {
-    const e = this.subscriptions.get(t);
-    return e ? (e(), this.subscriptions.delete(t), !0) : !1;
-  }
-  /**
-   * Очищает все подписки
-   *
-   * Вызывает функции отписки для всех активных подписок
-   * и очищает хранилище. Обычно используется при dispose узла формы.
-   *
-   * @example
-   * ```typescript
-   * class FieldNode {
-   *   private subscriptions = new SubscriptionManager();
-   *
-   *   dispose() {
-   *     // Отписываемся от всех effect
-   *     this.subscriptions.clear();
-   *   }
-   * }
-   * ```
-   */
-  clear() {
-    this.subscriptions.forEach((t) => {
-      t();
-    }), 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(t) {
-    return this.subscriptions.has(t);
-  }
-  /**
-   * Возвращает список всех ключей активных подписок
-   *
-   * Полезно для отладки: можно увидеть, какие подписки активны.
-   *
-   * @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();
-  }
-}
-var v = /* @__PURE__ */ ((r) => (r.THROW = "throw", r.LOG = "log", r.CONVERT = "convert", r))(v || {});
-class m {
-  /**
-   * Обработать ошибку согласно заданной стратегии
-   *
-   * @param error Ошибка для обработки (Error | string | unknown)
-   * @param context Контекст ошибки для логирования (например, 'AsyncValidator', 'BehaviorRegistry')
-   * @param strategy Стратегия обработки (THROW | LOG | CONVERT)
-   * @returns ValidationError если strategy = CONVERT, undefined если strategy = LOG, никогда не возвращается если strategy = THROW
-   *
-   * @example
-   * ```typescript
-   * // THROW - пробросить ошибку
-   * try {
-   *   riskyOperation();
-   * } catch (error) {
-   *   FormErrorHandler.handle(error, 'RiskyOperation', ErrorStrategy.THROW);
-   *   // Этот код никогда не выполнится
-   * }
-   *
-   * // LOG - залогировать и продолжить
-   * try {
-   *   nonCriticalOperation();
-   * } catch (error) {
-   *   FormErrorHandler.handle(error, 'NonCritical', ErrorStrategy.LOG);
-   *   // Продолжаем выполнение
-   * }
-   *
-   * // CONVERT - конвертировать в ValidationError
-   * try {
-   *   await validator(value);
-   * } catch (error) {
-   *   const validationError = FormErrorHandler.handle(
-   *     error,
-   *     'AsyncValidator',
-   *     ErrorStrategy.CONVERT
-   *   );
-   *   return validationError;
-   * }
-   * ```
-   */
-  static handle(t, e, i = "throw") {
-    const s = this.extractMessage(t);
-    switch (i) {
-      case "throw":
-        throw t;
-      case "log":
-        return;
-      case "convert":
-        return {
-          code: "validator_error",
-          message: s,
-          params: { field: e }
-        };
-    }
-  }
-  /**
-   * Извлечь сообщение из ошибки
-   *
-   * Обрабатывает различные типы ошибок:
-   * - Error объекты → error.message
-   * - Строки → возвращает как есть
-   * - Объекты с message → извлекает message
-   * - Другое → String(error)
-   *
-   * @param error Ошибка для извлечения сообщения
-   * @returns Сообщение ошибки
-   * @private
-   *
-   * @example
-   * ```typescript
-   * FormErrorHandler.extractMessage(new Error('Test'));
-   * // 'Test'
-   *
-   * FormErrorHandler.extractMessage('String error');
-   * // 'String error'
-   *
-   * FormErrorHandler.extractMessage({ message: 'Object error' });
-   * // 'Object error'
-   *
-   * FormErrorHandler.extractMessage(null);
-   * // 'null'
-   * ```
-   */
-  static extractMessage(t) {
-    return t instanceof Error ? t.message : typeof t == "string" ? t : typeof t == "object" && t !== null && "message" in t ? String(t.message) : String(t);
-  }
-  /**
-   * Создать ValidationError с заданными параметрами
-   *
-   * Утилитная функция для создания ValidationError объектов
-   *
-   * @param code Код ошибки
-   * @param message Сообщение ошибки
-   * @param field Поле (опционально)
-   * @returns ValidationError объект
-   *
-   * @example
-   * ```typescript
-   * const error = FormErrorHandler.createValidationError(
-   *   'required',
-   *   'This field is required',
-   *   'email'
-   * );
-   * // { code: 'required', message: 'This field is required', field: 'email' }
-   * ```
-   */
-  static createValidationError(t, e, i) {
-    return {
-      code: t,
-      message: e,
-      params: i ? { field: i } : void 0
-    };
-  }
-  /**
-   * Проверить, является ли объект ValidationError
-   *
-   * Type guard для ValidationError
-   *
-   * @param value Значение для проверки
-   * @returns true если value является ValidationError
-   *
-   * @example
-   * ```typescript
-   * if (FormErrorHandler.isValidationError(result)) {
-   *   console.log(result.code); // OK, типобезопасно
-   * }
-   * ```
-   */
-  static isValidationError(t) {
-    return typeof t == "object" && t !== null && "code" in t && "message" in t && typeof t.code == "string" && typeof t.message == "string";
-  }
-}
-class R extends g {
-  // ============================================================================
-  // Приватные сигналы
-  // ============================================================================
-  _value;
-  _errors;
-  // _touched, _dirty, _status наследуются от FormNode (protected)
-  _pending;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  _componentProps;
-  // ============================================================================
-  // Публичные computed signals
-  // ============================================================================
-  value;
-  valid;
-  invalid;
-  // touched, dirty, status наследуются от FormNode
-  pending;
-  errors;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  componentProps;
-  /**
-   * Вычисляемое свойство: нужно ли показывать ошибку
-   * Ошибка показывается если поле невалидно И (touched ИЛИ dirty)
-   */
-  shouldShowError;
-  // ============================================================================
-  // Конфигурация
-  // ============================================================================
-  validators;
-  asyncValidators;
-  updateOn;
-  initialValue;
-  currentValidationId = 0;
-  debounceMs;
-  validateDebounceTimer;
-  validateDebounceResolve;
-  /**
-   * Менеджер подписок для централизованного cleanup
-   * Использует SubscriptionManager вместо массива для управления подписками
-   */
-  disposers = new _();
-  component;
-  // ============================================================================
-  // Конструктор
-  // ============================================================================
-  constructor(t) {
-    super(), this.initialValue = t.value, this.validators = t.validators || [], this.asyncValidators = t.asyncValidators || [], this.updateOn = t.updateOn || "blur", this.debounceMs = t.debounce || 0, this.component = t.component, this._value = d(t.value), this._errors = d([]), this._pending = d(!1), this._componentProps = d(t.componentProps || {}), t.disabled && (this._status.value = "disabled"), this.value = l(() => this._value.value), this.valid = l(() => this._status.value === "valid"), this.invalid = l(() => this._status.value === "invalid"), this.pending = l(() => this._pending.value), this.errors = l(() => this._errors.value), this.componentProps = l(() => this._componentProps.value), this.shouldShowError = l(
-      () => this._status.value === "invalid" && (this._touched.value || this._dirty.value)
-    );
-  }
-  // ============================================================================
-  // Реализация абстрактных методов FormNode
-  // ============================================================================
-  getValue() {
-    return this._value.peek();
-  }
-  setValue(t, e) {
-    if (this._value.value = t, this._dirty.value = !0, e?.emitEvent === !1)
-      return;
-    const i = this.validators.length > 0 || this.asyncValidators.length > 0, s = this._errors.value.length > 0;
-    if (this.updateOn === "change") {
-      this.validate();
-      return;
-    }
-    s && i && this.validate();
-  }
-  patchValue(t) {
-    this.setValue(t);
-  }
-  /**
-   * Сбросить поле к указанному значению (или к initialValue)
-   *
-   * @param value - опциональное значение для сброса. Если не указано, используется initialValue
-   *
-   * @remarks
-   * Этот метод:
-   * - Устанавливает значение в value или initialValue
-   * - Очищает ошибки валидации
-   * - Сбрасывает touched/dirty флаги
-   * - Устанавливает статус в 'valid'
-   *
-   * Если вам нужно сбросить к исходному значению, используйте resetToInitial()
-   *
-   * @example
-   * ```typescript
-   * // Сброс к initialValue
-   * field.reset();
-   *
-   * // Сброс к новому значению
-   * field.reset('new value');
-   * ```
-   */
-  reset(t) {
-    this._value.value = t !== void 0 ? t : this.initialValue, this._errors.value = [], this._touched.value = !1, this._dirty.value = !1, this._status.value = "valid";
-  }
-  /**
-   * Сбросить поле к исходному значению (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);
-  }
-  /**
-   * Запустить валидацию поля
-   * @param options - опции валидации
-   * @returns `Promise<boolean>` - true если поле валидно
-   *
-   * @remarks
-   * Метод защищен от race conditions через validationId.
-   * При быстром вводе только последняя валидация применяет результаты.
-   *
-   * @example
-   * ```typescript
-   * // Обычная валидация
-   * await field.validate();
-   *
-   * // С debounce
-   * await field.validate({ debounce: 300 });
-   * ```
-   */
-  async validate(t) {
-    const e = t?.debounce ?? this.debounceMs;
-    return e > 0 && this.asyncValidators.length > 0 ? new Promise((i) => {
-      const s = this.currentValidationId;
-      this.validateDebounceResolve && this.validateDebounceResolve(!1), this.validateDebounceTimer && clearTimeout(this.validateDebounceTimer), this.validateDebounceResolve = i, this.validateDebounceTimer = setTimeout(async () => {
-        if (this.validateDebounceResolve = void 0, s !== this.currentValidationId) {
-          i(!1);
-          return;
-        }
-        const a = await this.validateImmediate();
-        i(a);
-      }, e);
-    }) : this.validateImmediate();
-  }
-  /**
-   * Немедленная валидация без debounce
-   * @private
-   * @remarks
-   * Защищена от race conditions:
-   * - Проверка validationId после синхронной валидации
-   * - Проверка перед установкой pending
-   * - Проверка после Promise.all
-   * - Проверка перед обработкой async результатов
-   * - Проверка перед очисткой errors
-   */
-  async validateImmediate() {
-    const t = ++this.currentValidationId, e = [];
-    for (const s of this.validators) {
-      const a = s(this._value.value);
-      a && e.push(a);
-    }
-    if (t !== this.currentValidationId)
-      return !1;
-    if (e.length > 0)
-      return this._errors.value = e, this._status.value = "invalid", !1;
-    if (this.asyncValidators.length > 0) {
-      if (t !== this.currentValidationId)
-        return !1;
-      this._pending.value = !0, this._status.value = "pending";
-      const s = await Promise.all(
-        this.asyncValidators.map(async (n) => {
-          try {
-            return await n(this._value.value);
-          } catch (o) {
-            return m.handle(
-              o,
-              "FieldNode AsyncValidator",
-              v.CONVERT
-            );
-          }
-        })
-      );
-      if (t !== this.currentValidationId || (this._pending.value = !1, t !== this.currentValidationId))
-        return !1;
-      const a = s.filter(Boolean);
-      if (a.length > 0)
-        return this._errors.value = a, this._status.value = "invalid", !1;
-    }
-    return t !== this.currentValidationId ? !1 : ((this.validators.length > 0 || this.asyncValidators.length > 0) && (this._errors.value = [], this._status.value = "valid"), this._errors.value.length === 0);
-  }
-  setErrors(t) {
-    this._errors.value = t, this._status.value = t.length > 0 ? "invalid" : "valid";
-  }
-  clearErrors() {
-    this._errors.value = [], this._status.value = "valid";
-  }
-  // ============================================================================
-  // Protected hooks (Template Method pattern)
-  // ============================================================================
-  /**
-   * Hook: вызывается после markAsTouched()
-   *
-   * Для FieldNode: если updateOn === 'blur', запускаем валидацию
-   */
-  onMarkAsTouched() {
-    this.updateOn === "blur" && this.validate();
-  }
-  /**
-   * Hook: вызывается после disable()
-   *
-   * Для FieldNode: очищаем ошибки валидации
-   */
-  onDisable() {
-    this._errors.value = [];
-  }
-  /**
-   * Hook: вызывается после enable()
-   *
-   * Для FieldNode: запускаем валидацию
-   */
-  onEnable() {
-    this.validate();
-  }
-  /**
-   * Обновляет свойства компонента (например, опции для Select)
-   *
-   * @example
-   * ```typescript
-   * // Обновление опций для Select после загрузки справочников
-   * form.registrationAddress.city.updateComponentProps({
-   *   options: cities
-   * });
-   * ```
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  updateComponentProps(t) {
-    this._componentProps.value = {
-      ...this._componentProps.value,
-      ...t
-    };
-  }
-  /**
-   * Динамически изменяет триггер валидации (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(t) {
-    this.updateOn = t;
-  }
-  getUpdateOn() {
-    return this.updateOn;
-  }
-  // ============================================================================
-  // Методы-помощники для реактивности (Фаза 1)
-  // ============================================================================
-  /**
-   * Подписка на изменения значения поля
-   * Автоматически отслеживает изменения через @preact/signals effect
-   *
-   * @param callback - Функция, вызываемая при изменении значения
-   * @returns Функция отписки для cleanup
-   *
-   * @example
-   * ```typescript
-   * const unsubscribe = form.email.watch((value) => {
-   *   console.log('Email changed:', value);
-   * });
-   *
-   * // Cleanup
-   * useEffect(() => unsubscribe, []);
-   * ```
-   */
-  watch(t) {
-    const e = c(() => {
-      const s = this.value.value;
-      t(s);
-    }), i = `watch-${Date.now()}-${Math.random()}`;
-    return this.disposers.add(i, e);
-  }
-  /**
-   * Вычисляемое значение из других полей
-   * Автоматически обновляет текущее поле при изменении источников
-   *
-   * @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(t, e) {
-    const i = c(() => {
-      const a = t.map((o) => o.value), n = e(...a);
-      this.setValue(n, { emitEvent: !1 });
-    }), s = `computeFrom-${Date.now()}-${Math.random()}`;
-    return this.disposers.add(s, i);
-  }
-  /**
-   * Очистить все ресурсы и таймеры
-   * Должен вызываться при unmount компонента
-   *
-   * @example
-   * ```typescript
-   * useEffect(() => {
-   *   return () => {
-   *     field.dispose();
-   *   };
-   * }, []);
-   * ```
-   */
-  dispose() {
-    this.disposers.dispose(), this.validateDebounceTimer && (clearTimeout(this.validateDebounceTimer), this.validateDebounceTimer = void 0);
-  }
-}
-function S() {
-  return b("");
-}
-function b(r) {
-  return new Proxy({}, {
-    get(t, e) {
-      if (typeof e == "symbol")
-        return;
-      if (e === "__path")
-        return r || e;
-      if (e === "__key") {
-        const a = r.split(".");
-        return a[a.length - 1] || e;
-      }
-      if (e === "then" || e === "catch" || e === "finally" || e === "constructor" || e === "toString" || e === "valueOf" || e === "toJSON")
-        return;
-      const i = r ? `${r}.${e}` : e, s = {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        __key: e,
-        __path: i,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        __formType: void 0,
-        __fieldType: void 0
-      };
-      return new Proxy(s, {
-        get(a, n) {
-          if (typeof n != "symbol") {
-            if (n === "__path") return i;
-            if (n === "__key") return e;
-            if (n !== "__formType" && n !== "__fieldType" && !(n === "then" || n === "catch" || n === "finally" || n === "constructor" || n === "toString" || n === "valueOf" || n === "toJSON"))
-              return b(`${i}.${n}`);
-          }
-        }
-      });
-    }
-  });
-}
-function x(r) {
-  if (typeof r == "string")
-    return r;
-  if (r && typeof r == "object") {
-    const t = r.__path;
-    if (typeof t == "string")
-      return t;
-  }
-  throw new Error("Invalid field path node: " + JSON.stringify(r));
-}
-function L(r) {
-  const t = x(r);
-  return b(t);
-}
-function K(r) {
-  if (r && typeof r == "object" && "__key" in r)
-    return r.__key;
-  if (typeof r == "string") {
-    const t = r.split(".");
-    return t[t.length - 1];
-  }
-  throw new Error("Invalid field path node");
-}
-class E extends g {
-  // ============================================================================
-  // Приватные поля
-  // ============================================================================
-  items;
-  itemSchema;
-  initialItems;
-  /**
-   * Менеджер подписок для централизованного cleanup
-   * Использует SubscriptionManager вместо массива для управления подписками
-   */
-  disposers = new _();
-  // ============================================================================
-  // Приватные поля для сохранения схем
-  // ============================================================================
-  validationSchemaFn;
-  behaviorSchemaFn;
-  // ============================================================================
-  // Публичные computed signals
-  // ============================================================================
-  value;
-  valid;
-  invalid;
-  touched;
-  dirty;
-  pending;
-  errors;
-  status;
-  length;
-  // ============================================================================
-  // Конструктор
-  // ============================================================================
-  constructor(t, e = []) {
-    super(), this.itemSchema = t, this.initialItems = e, this.items = d([]);
-    for (const i of e)
-      this.push(i);
-    this.length = l(() => this.items.value.length), this.value = l(() => this.items.value.map((i) => i.value.value)), this.valid = l(() => this.items.value.every((i) => i.valid.value)), this.invalid = l(() => !this.valid.value), this.pending = l(() => this.items.value.some((i) => i.pending.value)), this.touched = l(() => this.items.value.some((i) => i.touched.value)), this.dirty = l(() => this.items.value.some((i) => i.dirty.value)), this.errors = l(() => {
-      const i = [];
-      return this.items.value.forEach((s) => {
-        i.push(...s.errors.value);
-      }), i;
-    }), this.status = l(() => this.pending.value ? "pending" : this.invalid.value ? "invalid" : "valid");
-  }
-  // ============================================================================
-  // CRUD операции
-  // ============================================================================
-  /**
-   * Добавить элемент в конец массива
-   * @param initialValue - Начальные значения для нового элемента
-   */
-  push(t) {
-    const e = this.createItem(t);
-    this.items.value = [...this.items.value, e];
-  }
-  /**
-   * Удалить элемент по индексу
-   * @param index - Индекс элемента для удаления
-   */
-  removeAt(t) {
-    t < 0 || t >= this.items.value.length || (this.items.value = this.items.value.filter((e, i) => i !== t));
-  }
-  /**
-   * Вставить элемент в массив
-   * @param index - Индекс для вставки
-   * @param initialValue - Начальные значения для нового элемента
-   */
-  insert(t, e) {
-    if (t < 0 || t > this.items.value.length)
-      return;
-    const i = this.createItem(e), s = [...this.items.value];
-    s.splice(t, 0, i), this.items.value = s;
-  }
-  /**
-   * Удалить все элементы массива
-   */
-  clear() {
-    this.items.value = [];
-  }
-  /**
-   * Получить элемент по индексу
-   * @param index - Индекс элемента
-   * @returns Типизированный GroupNode или undefined если индекс вне границ
-   */
-  at(t) {
-    return this.items.value[t];
-  }
-  // ============================================================================
-  // Реализация абстрактных методов
-  // ============================================================================
-  getValue() {
-    return this.items.value.map((t) => t.getValue());
-  }
-  setValue(t, e) {
-    this.clear(), t.forEach((i) => this.push(i)), e?.emitEvent !== !1 && this.validate().catch(() => {
-    });
-  }
-  patchValue(t) {
-    t.forEach((e, i) => {
-      this.items.value[i] && e !== void 0 && this.items.value[i].patchValue(e);
-    });
-  }
-  /**
-   * Сбросить массив к указанным значениям (или очистить)
-   *
-   * @param values - опциональный массив значений для сброса
-   *
-   * @remarks
-   * Очищает текущий массив и заполняет новыми элементами
-   *
-   * @example
-   * ```typescript
-   * // Очистить массив
-   * arrayNode.reset();
-   *
-   * // Сбросить к новым значениям
-   * arrayNode.reset([{ name: 'Item 1' }, { name: 'Item 2' }]);
-   * ```
-   */
-  reset(t) {
-    this.clear(), t && t.forEach((e) => this.push(e));
-  }
-  /**
-   * Сбросить массив к исходным значениям (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.clear(), this.initialItems.forEach((t) => this.push(t));
-  }
-  async validate() {
-    return (await Promise.all(this.items.value.map((e) => e.validate()))).every(Boolean);
-  }
-  setErrors(t) {
-  }
-  clearErrors() {
-    this.items.value.forEach((t) => t.clearErrors());
-  }
-  // ============================================================================
-  // Protected hooks (Template Method pattern)
-  // ============================================================================
-  /**
-   * Hook: вызывается после markAsTouched()
-   *
-   * Для ArrayNode: рекурсивно помечаем все элементы массива как touched
-   */
-  onMarkAsTouched() {
-    this.items.value.forEach((t) => t.markAsTouched());
-  }
-  /**
-   * Hook: вызывается после markAsUntouched()
-   *
-   * Для ArrayNode: рекурсивно помечаем все элементы массива как untouched
-   */
-  onMarkAsUntouched() {
-    this.items.value.forEach((t) => t.markAsUntouched());
-  }
-  /**
-   * Hook: вызывается после markAsDirty()
-   *
-   * Для ArrayNode: рекурсивно помечаем все элементы массива как dirty
-   */
-  onMarkAsDirty() {
-    this.items.value.forEach((t) => t.markAsDirty());
-  }
-  /**
-   * Hook: вызывается после markAsPristine()
-   *
-   * Для ArrayNode: рекурсивно помечаем все элементы массива как pristine
-   */
-  onMarkAsPristine() {
-    this.items.value.forEach((t) => t.markAsPristine());
-  }
-  // ============================================================================
-  // Итерация
-  // ============================================================================
-  /**
-   * Итерировать по элементам массива
-   * @param callback - Функция, вызываемая для каждого элемента с типизированным GroupNode
-   */
-  forEach(t) {
-    this.items.value.forEach((e, i) => {
-      t(e, i);
-    });
-  }
-  /**
-   * Маппинг элементов массива
-   * @param callback - Функция преобразования с типизированным GroupNode
-   * @returns Новый массив результатов
-   */
-  map(t) {
-    return this.items.value.map((e, i) => t(e, i));
-  }
-  // ============================================================================
-  // Private методы
-  // ============================================================================
-  /**
-   * Создать новый элемент массива на основе схемы
-   * @param initialValue - Начальные значения
-   */
-  createItem(t) {
-    if (this.isGroupSchema(this.itemSchema)) {
-      const e = new y(this.itemSchema);
-      return t && e.patchValue(t), this.validationSchemaFn && "applyValidationSchema" in e && e.applyValidationSchema(this.validationSchemaFn), this.behaviorSchemaFn && "applyBehaviorSchema" in e && e.applyBehaviorSchema(this.behaviorSchemaFn), e;
-    }
-    throw new Error(
-      "ArrayNode поддерживает только GroupNode элементы. Для массива примитивов используйте обычное поле с типом массива."
-    );
-  }
-  /**
-   * Проверить, является ли схема групповой (объект полей)
-   * @param schema - Схема для проверки
-   */
-  isGroupSchema(t) {
-    return typeof t == "object" && t !== null && !("component" in t) && !Array.isArray(t);
-  }
-  // ============================================================================
-  // Validation Schema
-  // ============================================================================
-  /**
-   * Применить validation schema ко всем элементам массива
-   *
-   * Validation schema будет применена к:
-   * - Всем существующим элементам
-   * - Всем новым элементам, добавляемым через push/insert
-   *
-   * @param schemaFn - Функция валидации для элемента массива
-   *
-   * @example
-   * ```typescript
-   * import { propertyValidation } from './validation/property-validation';
-   *
-   * form.properties.applyValidationSchema(propertyValidation);
-   * ```
-   */
-  applyValidationSchema(t) {
-    this.validationSchemaFn = t, this.items.value.forEach((e) => {
-      "applyValidationSchema" in e && typeof e.applyValidationSchema == "function" && e.applyValidationSchema(t);
-    });
-  }
-  /**
-   * Применить behavior schema ко всем элементам ArrayNode
-   *
-   * Автоматически применяется к новым элементам при push/insert.
-   *
-   * @param schemaFn - Behavior schema функция
-   *
-   * @example
-   * ```typescript
-   * import { addressBehavior } from './behaviors/address-behavior';
-   *
-   * form.addresses.applyBehaviorSchema(addressBehavior);
-   * ```
-   */
-  applyBehaviorSchema(t) {
-    this.behaviorSchemaFn = t, this.items.value.forEach((e) => {
-      "applyBehaviorSchema" in e && typeof e.applyBehaviorSchema == "function" && e.applyBehaviorSchema(t);
-    });
-  }
-  // ============================================================================
-  // Методы-помощники для реактивности (Фаза 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(t, e) {
-    const i = c(() => {
-      const a = this.items.value.map((n) => {
-        if (n instanceof y)
-          return n.getFieldByPath(t)?.value.value;
-      });
-      e(a);
-    }), s = `watchItems-${Date.now()}-${Math.random()}`;
-    return this.disposers.add(s, i);
-  }
-  /**
-   * Подписка на изменение длины массива
-   * Срабатывает при добавлении/удалении элементов
-   *
-   * @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(t) {
-    const e = c(() => {
-      const s = this.length.value;
-      t(s);
-    }), i = `watchLength-${Date.now()}-${Math.random()}`;
-    return this.disposers.add(i, e);
-  }
-  /**
-   * Очистить все ресурсы узла
-   * Рекурсивно очищает все subscriptions и элементы массива
-   *
-   * @example
-   * ```typescript
-   * useEffect(() => {
-   *   return () => {
-   *     arrayNode.dispose();
-   *   };
-   * }, []);
-   * ```
-   */
-  dispose() {
-    this.disposers.dispose(), this.items.value.forEach((t) => {
-      "dispose" in t && typeof t.dispose == "function" && t.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((t) => {
-      t.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((t) => {
-      t.enable();
-    });
-  }
-}
-function f(r) {
-  return r == null ? !1 : typeof r == "object" && "value" in r && "setValue" in r && "getValue" in r && "validate" in r;
-}
-function p(r) {
-  return r == null ? !1 : f(r) && "validators" in r && "asyncValidators" in r && // FieldNode имеет markAsTouched метод
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  typeof r.markAsTouched == "function" && // У FieldNode нет fields или items
-  !("fields" in r) && !("items" in r);
-}
-function M(r) {
-  return r == null ? !1 : f(r) && "applyValidationSchema" in r && "applyBehaviorSchema" in r && "getFieldByPath" in r && // GroupNode НЕ имеет items/push/removeAt (это ArrayNode)
-  !("items" in r) && !("push" in r) && !("removeAt" in r);
-}
-function P(r) {
-  return r == null ? !1 : f(r) && "items" in r && "length" in r && "push" in r && "removeAt" in r && "at" in r && // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  typeof r.push == "function" && // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  typeof r.removeAt == "function";
-}
-function z(r) {
-  return p(r) ? "FieldNode" : M(r) ? "GroupNode" : P(r) ? "ArrayNode" : f(r) ? "FormNode" : "Unknown";
-}
-class N {
-  _form;
-  control;
-  /**
-   * Форма с типизированным Proxy-доступом к полям
-   */
-  form;
-  constructor(t, e, i) {
-    this._form = t, this.control = i, this.form = t._proxyInstance || t.getProxy();
-  }
-  /**
-   * Получить текущее значение поля (внутренний метод для validation-applicator)
-   * @internal
-   */
-  value() {
-    return this.control.value.value;
-  }
-  /**
-   * Безопасно установить значение поля по строковому пути
-   * Автоматически использует emitEvent: false для предотвращения циклов
-   */
-  setFieldValue(t, e) {
-    const i = this._form.getFieldByPath(t);
-    i && f(i) && i.setValue(e, { emitEvent: !1 });
-  }
-}
-class I {
-  _form;
-  /**
-   * Форма с типизированным Proxy-доступом к полям
-   */
-  form;
-  constructor(t) {
-    this._form = t, this.form = t._proxyInstance || t.getProxy();
-  }
-  /**
-   * Безопасно установить значение поля по строковому пути
-   * Автоматически использует emitEvent: false для предотвращения циклов
-   */
-  setFieldValue(t, e) {
-    const i = this._form.getFieldByPath(t);
-    i && f(i) && i.setValue(e, { emitEvent: !1 });
-  }
-}
-class T {
-  form;
-  constructor(t) {
-    this.form = t;
-  }
-  /**
-   * Применить валидаторы к полям формы
-   *
-   * Этапы применения:
-   * 1. Разделение валидаторов на field и tree
-   * 2. Применение field валидаторов (sync/async)
-   * 3. Применение tree валидаторов (кросс-полевая валидация)
-   *
-   * @param validators Зарегистрированные валидаторы
-   */
-  async apply(t) {
-    const { validatorsByField: e, treeValidators: i } = this.groupValidators(t);
-    await this.applyFieldValidators(e), this.applyTreeValidators(i);
-  }
-  /**
-   * Группировка валидаторов по типам
-   *
-   * Разделяет валидаторы на:
-   * - Field validators (sync/async) - группируются по fieldPath
-   * - Tree validators - применяются ко всей форме
-   *
-   * @param validators Все зарегистрированные валидаторы
-   * @returns Сгруппированные валидаторы
-   */
-  groupValidators(t) {
-    const e = /* @__PURE__ */ new Map(), i = [];
-    for (const s of t)
-      if (s.type === "tree")
-        i.push(s);
-      else {
-        const a = e.get(s.fieldPath) || [];
-        a.push(s), e.set(s.fieldPath, a);
-      }
-    return { validatorsByField: e, treeValidators: i };
-  }
-  /**
-   * Применение field валидаторов к полям
-   *
-   * Для каждого поля:
-   * 1. Найти FieldNode по пути
-   * 2. Проверить условия (condition)
-   * 3. Выполнить sync/async валидаторы
-   * 4. Установить ошибки на поле
-   *
-   * @param validatorsByField Валидаторы, сгруппированные по полям
-   */
-  async applyFieldValidators(t) {
-    for (const [e, i] of t) {
-      const s = this.form.getFieldByPath(e);
-      if (!s) {
-        console.warn(`Field ${e} not found in GroupNode`);
-        continue;
-      }
-      if (!p(s)) {
-        process.env.NODE_ENV !== "production" && console.warn(`Validation can only run on FieldNode, skipping ${e}`);
-        continue;
-      }
-      const a = [], n = new N(this.form, e, s);
-      for (const o of i)
-        if (!(o.condition && !this.checkCondition(o.condition)))
-          try {
-            let h = null;
-            const u = n.value(), V = o.validator;
-            o.type === "sync" ? h = V(u, n) : o.type === "async" && (h = await V(u, n)), h && a.push(h);
-          } catch (h) {
-            m.handle(
-              h,
-              `ValidationApplicator: validator for ${e}`,
-              v.LOG
-            );
-          }
-      a.length > 0 ? s.setErrors(a) : s.errors.value.length > 0 && !s.errors.value.some((o) => o.code !== "contextual") && s.clearErrors();
-    }
-  }
-  /**
-   * Применение tree валидаторов (кросс-полевая валидация)
-   *
-   * Tree валидаторы имеют доступ ко всей форме через TreeValidationContext.
-   * Ошибки устанавливаются на targetField (если указано).
-   *
-   * @param treeValidators Список tree валидаторов
-   */
-  applyTreeValidators(t) {
-    for (const e of t) {
-      const i = new I(this.form);
-      if (!(e.condition && !this.checkCondition(e.condition)))
-        try {
-          if (e.type !== "tree")
-            continue;
-          const s = e.validator(i);
-          if (s && e.options && "targetField" in e.options) {
-            const a = e.options.targetField;
-            if (a) {
-              const n = this.form.getFieldByPath(String(a));
-              if (n && p(n)) {
-                const o = n.errors.value;
-                n.setErrors([...o, s]);
-              }
-            }
-          }
-        } catch (s) {
-          m.handle(s, "ValidationApplicator: tree validator", v.LOG);
-        }
-    }
-  }
-  /**
-   * Проверка условия (condition) для валидатора
-   *
-   * Условие определяет, должен ли валидатор выполняться.
-   * Использует getFieldByPath для поддержки вложенных путей.
-   *
-   * @param condition Условие валидатора
-   * @returns true, если условие выполнено
-   */
-  checkCondition(t) {
-    const e = this.form.getFieldByPath(t.fieldPath);
-    if (!e)
-      return !1;
-    const i = e.value.value;
-    return t.conditionFn(i);
-  }
-}
-class D {
-  form;
-  behaviorRegistry;
-  constructor(t, e) {
-    this.form = t, this.behaviorRegistry = e;
-  }
-  /**
-   * Применить behavior схему к форме
-   *
-   * Этапы:
-   * 1. Начать регистрацию (beginRegistration)
-   * 2. Выполнить схему (регистрация behaviors)
-   * 3. Завершить регистрацию (endRegistration) - применить behaviors
-   * 4. Вернуть функцию cleanup для отписки
-   *
-   * @param schemaFn Функция-схема behavior
-   * @returns Функция отписки от всех behaviors
-   *
-   * @example
-   * ```typescript
-   * const cleanup = behaviorApplicator.apply((path) => {
-   *   copyFrom(path.residenceAddress, path.registrationAddress, {
-   *     when: (form) => form.sameAsRegistration === true
-   *   });
-   *
-   *   enableWhen(path.propertyValue, (form) => form.loanType === 'mortgage');
-   *
-   *   computeFrom(
-   *     path.initialPayment,
-   *     [path.propertyValue],
-   *     (propertyValue) => propertyValue ? propertyValue * 0.2 : null
-   *   );
-   * });
-   *
-   * // Cleanup при unmount
-   * useEffect(() => cleanup, []);
-   * ```
-   */
-  apply(t) {
-    this.behaviorRegistry.beginRegistration();
-    try {
-      const e = w();
-      t(e);
-      const i = this.form.getProxy();
-      return this.behaviorRegistry.endRegistration(i).cleanup;
-    } catch (e) {
-      throw m.handle(e, "BehaviorApplicator", v.THROW), e;
-    }
-  }
-}
-class B {
-  /**
-   * Парсит путь в массив сегментов
-   *
-   * Поддерживаемые форматы:
-   * - Простые пути: "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(t) {
-    const e = [];
-    let i = "", s = !1;
-    for (let a = 0; a < t.length; a++) {
-      const n = t[a];
-      n === "[" ? (s = !0, i += n) : n === "]" ? (s = !1, i += n) : n === "." && !s ? i && (this.addSegment(e, i), i = "") : i += n;
-    }
-    return i && this.addSegment(e, i), e;
-  }
-  /**
-   * Добавляет сегмент в массив, обрабатывая массивы
-   * @private
-   */
-  addSegment(t, e) {
-    const i = e.match(/^(.+)\[(\d+)\]$/);
-    i ? t.push({
-      key: i[1],
-      index: parseInt(i[2], 10)
-    }) : t.push({ key: e });
-  }
-  /**
-   * Получает значение по пути из объекта
-   *
-   * Проходит по всем сегментам пути и возвращает конечное значение.
-   * Если путь не найден, возвращает 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(t, e) {
-    const i = this.parsePath(e);
-    let s = t;
-    for (const a of i) {
-      if (s == null) return;
-      if (s = s[a.key], a.index !== void 0) {
-        if (!Array.isArray(s)) return;
-        s = s[a.index];
-      }
-    }
-    return s;
-  }
-  /**
-   * Устанавливает значение по пути в объекте (мутирует объект)
-   *
-   * Создает промежуточные объекты, если они не существуют.
-   * Выбрасывает ошибку, если ожидается массив, но его нет.
-   *
-   * @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(t, e, i) {
-    const s = this.parsePath(e);
-    if (s.length === 0)
-      throw new Error("Cannot set value: empty path");
-    let a = t;
-    for (let o = 0; o < s.length - 1; o++) {
-      const h = s[o];
-      let u = a[h.key];
-      if (h.index !== void 0) {
-        if (!Array.isArray(u))
-          throw new Error(`Expected array at path segment: ${h.key}, but got ${typeof u}`);
-        a = u[h.index];
-      } else
-        u == null && (a[h.key] = {}, u = a[h.key]), a = u;
-    }
-    const n = s[s.length - 1];
-    if (n.index !== void 0) {
-      const o = a[n.key];
-      if (!Array.isArray(o))
-        throw new Error(
-          `Expected array at path segment: ${n.key}, but got ${typeof o}`
-        );
-      o[n.index] = i;
-    } else
-      a[n.key] = i;
-  }
-  /**
-   * Получить значение из 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(t, e) {
-    const i = this.getNodeByPath(t, e);
-    if (i != null)
-      return this.isFormNode(i) ? i.value.value : i;
-  }
-  /**
-   * Type guard для проверки, является ли объект FormNode
-   *
-   * Проверяет наличие характерных свойств FormNode:
-   * - value (Signal)
-   * - value.value (значение Signal)
-   *
-   * @param obj Объект для проверки
-   * @returns true, если объект является FormNode
-   * @private
-   */
-  isFormNode(t) {
-    return t != null && typeof t == "object" && "value" in t && typeof t.value == "object" && t.value != null && "value" in t.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(t, e) {
-    const i = this.parsePath(e);
-    let s = t;
-    for (const a of i) {
-      if (s == null) return null;
-      const n = s;
-      if (n.fields && n.fields instanceof Map) {
-        if (s = n.fields.get(a.key), a.index === void 0) {
-          if (s == null) return null;
-          continue;
-        }
-      } else if (a.index !== void 0 && n.items) {
-        const o = n.items.value || n.items;
-        if (!Array.isArray(o) || (s = o[a.index], s == null)) return null;
-        continue;
-      } else if (a.index === void 0) {
-        if (s = n[a.key], s == null) return null;
-        continue;
-      }
-      if (s && a.index !== void 0 && s.items) {
-        const o = s.items.value || s.items;
-        if (!Array.isArray(o)) return null;
-        s = o[a.index];
-      } else if (s && a.index !== void 0 && !s.items)
-        return null;
-      if (s == null) return null;
-    }
-    return s;
-  }
-}
-class O {
-  /**
-   * Внутреннее хранилище полей
-   * Map обеспечивает быструю lookup производительность O(1)
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  fields = /* @__PURE__ */ new Map();
-  /**
-   * Установить поле в реестр
-   *
-   * @param key - Ключ поля (имя свойства в типе T)
-   * @param node - FormNode для этого поля
-   *
-   * @example
-   * ```typescript
-   * registry.set('email', new FieldNode({ value: '' }));
-   * ```
-   */
-  set(t, e) {
-    this.fields.set(t, e);
-  }
-  /**
-   * Получить поле из реестра
-   *
-   * @param key - Ключ поля
-   * @returns FormNode или undefined, если поле не найдено
-   *
-   * @example
-   * ```typescript
-   * const emailField = registry.get('email');
-   * if (emailField) {
-   *   console.log(emailField.value.value);
-   * }
-   * ```
-   */
-  get(t) {
-    return this.fields.get(t);
-  }
-  /**
-   * Проверить наличие поля в реестре
-   *
-   * @param key - Ключ поля
-   * @returns true если поле существует
-   *
-   * @example
-   * ```typescript
-   * if (registry.has('email')) {
-   *   console.log('Email field exists');
-   * }
-   * ```
-   */
-  has(t) {
-    return this.fields.has(t);
-  }
-  /**
-   * Удалить поле из реестра
-   *
-   * @param key - Ключ поля
-   * @returns true если поле было удалено, false если поля не было
-   *
-   * @example
-   * ```typescript
-   * registry.delete('email');
-   * ```
-   */
-  delete(t) {
-    return this.fields.delete(t);
-  }
-  /**
-   * Перебрать все поля
-   *
-   * @param callback - Функция обратного вызова для каждого поля
-   *
-   * @example
-   * ```typescript
-   * registry.forEach((field, key) => {
-   *   console.log(`${key}: ${field.value.value}`);
-   * });
-   * ```
-   */
-  forEach(t) {
-    this.fields.forEach(t);
-  }
-  /**
-   * Получить итератор значений (полей)
-   *
-   * @returns Итератор по всем полям
-   *
-   * @example
-   * ```typescript
-   * for (const field of registry.values()) {
-   *   await field.validate();
-   * }
-   * ```
-   */
-  values() {
-    return this.fields.values();
-  }
-  /**
-   * Получить итератор пар [ключ, значение]
-   *
-   * @returns Итератор по всем записям
-   *
-   * @example
-   * ```typescript
-   * for (const [key, field] of registry.entries()) {
-   *   console.log(key, field.value.value);
-   * }
-   * ```
-   */
-  entries() {
-    return this.fields.entries();
-  }
-  /**
-   * Получить итератор ключей полей
-   *
-   * @returns Итератор по всем ключам
-   *
-   * @example
-   * ```typescript
-   * const fieldNames = Array.from(registry.keys());
-   * // ['email', 'name', 'age']
-   * ```
-   */
-  keys() {
-    return this.fields.keys();
-  }
-  /**
-   * Получить количество полей
-   *
-   * @returns Количество зарегистрированных полей
-   *
-   * @example
-   * ```typescript
-   * console.log(`Form has ${registry.size()} fields`);
-   * ```
-   */
-  size() {
-    return this.fields.size;
-  }
-  /**
-   * Очистить все поля
-   *
-   * Удаляет все поля из реестра
-   *
-   * @example
-   * ```typescript
-   * registry.clear();
-   * console.log(registry.size()); // 0
-   * ```
-   */
-  clear() {
-    this.fields.clear();
-  }
-  /**
-   * Получить все поля как массив
-   *
-   * Полезно для операций, требующих работу с массивом
-   *
-   * @returns Массив всех полей
-   *
-   * @example
-   * ```typescript
-   * const allValid = registry.toArray().every(field => field.valid.value);
-   * ```
-   */
-  toArray() {
-    return Array.from(this.fields.values());
-  }
-  /**
-   * Получить Map-представление реестра (readonly)
-   *
-   * Используйте для совместимости с существующим кодом
-   *
-   * @returns ReadonlyMap с полями
-   * @internal
-   *
-   * @example
-   * ```typescript
-   * const mapView = registry.asMap();
-   * ```
-   */
-  asMap() {
-    return this.fields;
-  }
-}
-class C {
-  /**
-   * @param fieldRegistry - Реестр полей для доступа к коллекции
-   */
-  constructor(t) {
-    this.fieldRegistry = t;
-  }
-  /**
-   * Создать Proxy для GroupNode
-   *
-   * Proxy позволяет обращаться к полям формы напрямую:
-   * - form.email вместо form.fields.get('email')
-   * - form.address.city вместо form.fields.get('address').fields.get('city')
-   *
-   * @param target - GroupNode для которого создается Proxy
-   * @returns Proxy с типобезопасным доступом к полям
-   *
-   * @example
-   * ```typescript
-   * const proxy = proxyBuilder.build(groupNode);
-   *
-   * // Доступ к полям
-   * console.log(proxy.email.value); // Работает!
-   * console.log(proxy.name.value);  // Работает!
-   *
-   * // Доступ к методам GroupNode
-   * await proxy.validate(); // Работает!
-   * proxy.markAsTouched();  // Работает!
-   *
-   * // Проверка существования
-   * if ('email' in proxy) { ... }
-   *
-   * // Перечисление ключей
-   * Object.keys(proxy); // ['email', 'name', ...]
-   * ```
-   */
-  build(t) {
-    return new Proxy(t, {
-      /**
-       * Get trap: Перехват доступа к свойствам
-       *
-       * Приоритет:
-       * 1. Собственные свойства и методы GroupNode (validate, setValue и т.д.)
-       * 2. Поля формы из fieldRegistry
-       * 3. undefined для несуществующих свойств
-       */
-      get: (e, i) => {
-        if (i in e)
-          return e[i];
-        if (typeof i == "string" && this.fieldRegistry.has(i))
-          return this.fieldRegistry.get(i);
-      },
-      /**
-       * Set trap: Перехват установки свойств
-       *
-       * Запрещает прямую установку значений полей через form.email = value
-       * Пользователь должен использовать form.email.setValue(value) или form.setValue({...})
-       */
-      set: (e, i, s) => typeof i == "string" && this.fieldRegistry.has(i) ? !1 : (e[i] = s, !0),
-      /**
-       * Has trap: Перехват оператора 'in'
-       *
-       * Позволяет проверять существование полей:
-       * if ('email' in form) { ... }
-       */
-      has: (e, i) => typeof i == "string" && this.fieldRegistry.has(i) ? !0 : i in e,
-      /**
-       * OwnKeys trap: Перехват Object.keys() / Object.getOwnPropertyNames()
-       *
-       * Возвращает объединенный список:
-       * - Ключей самого GroupNode
-       * - Ключей полей из fieldRegistry
-       */
-      ownKeys: (e) => {
-        const i = Reflect.ownKeys(e), s = Array.from(this.fieldRegistry.keys());
-        return [.../* @__PURE__ */ new Set([...i, ...s])];
-      },
-      /**
-       * GetOwnPropertyDescriptor trap: Перехват Object.getOwnPropertyDescriptor()
-       *
-       * Возвращает дескриптор свойства для полей и свойств GroupNode
-       * Важно для корректной работы Object.keys() и других рефлексивных операций
-       */
-      getOwnPropertyDescriptor: (e, i) => typeof i == "string" && this.fieldRegistry.has(i) ? {
-        enumerable: !0,
-        // Поле должно быть перечисляемым
-        configurable: !0
-        // Поле может быть удалено
-        // Не указываем writable, т.к. это accessor property через get/set traps
-      } : Reflect.getOwnPropertyDescriptor(e, i)
-    });
-  }
-}
-class $ {
-  // ============================================================================
-  // Конструктор
-  // ============================================================================
-  /**
-   * Создать менеджер состояния
-   *
-   * @param fieldRegistry - реестр полей формы
-   */
-  constructor(t) {
-    this.fieldRegistry = t, this._submitting = d(!1), this._disabled = d(!1), this._formErrors = d([]), this.value = l(() => {
-      const e = {};
-      return this.fieldRegistry.forEach((i, s) => {
-        e[s] = i.value.value;
-      }), e;
-    }), this.valid = l(() => this._formErrors.value.length > 0 ? !1 : Array.from(this.fieldRegistry.values()).every((i) => i.valid.value)), this.invalid = l(() => !this.valid.value), this.pending = l(
-      () => Array.from(this.fieldRegistry.values()).some((e) => e.pending.value)
-    ), this.touched = l(
-      () => Array.from(this.fieldRegistry.values()).some((e) => e.touched.value)
-    ), this.dirty = l(
-      () => Array.from(this.fieldRegistry.values()).some((e) => e.dirty.value)
-    ), this.errors = l(() => {
-      const e = [];
-      return e.push(...this._formErrors.value), this.fieldRegistry.forEach((i) => {
-        e.push(...i.errors.value);
-      }), e;
-    }), this.status = l(() => this._disabled.value ? "disabled" : this.pending.value ? "pending" : this.invalid.value ? "invalid" : "valid"), this.submitting = l(() => this._submitting.value);
-  }
-  // ============================================================================
-  // Приватные сигналы (мутабельные)
-  // ============================================================================
-  /**
-   * Флаг отправки формы
-   * Устанавливается в true во время отправки формы на сервер
-   */
-  _submitting;
-  /**
-   * Флаг disabled состояния
-   * Если true, форма считается disabled
-   */
-  _disabled;
-  /**
-   * Form-level validation errors (не связанные с конкретным полем)
-   * Используется для server-side errors или кросс-полевой валидации
-   */
-  _formErrors;
-  // ============================================================================
-  // Публичные computed signals (read-only)
-  // ============================================================================
-  /**
-   * Значение формы как объект
-   *
-   * Computed signal, который автоматически пересчитывается при изменении любого поля.
-   * Использует мемоизацию - если зависимости не изменились, вернет закешированный объект.
-   *
-   * @example
-   * ```typescript
-   * const form = new GroupNode({ email: { value: 'test@mail.com' } });
-   * console.log(form.value.value); // { email: 'test@mail.com' }
-   * ```
-   */
-  value;
-  /**
-   * Форма валидна?
-   *
-   * Computed signal. Форма валидна, если:
-   * - Нет form-level errors
-   * - Все поля валидны
-   */
-  valid;
-  /**
-   * Форма невалидна?
-   *
-   * Computed signal. Инверсия valid.
-   */
-  invalid;
-  /**
-   * Хотя бы одно поле touched?
-   *
-   * Computed signal. Возвращает true, если хотя бы одно поле было touched.
-   */
-  touched;
-  /**
-   * Хотя бы одно поле dirty?
-   *
-   * Computed signal. Возвращает true, если хотя бы одно поле изменилось.
-   */
-  dirty;
-  /**
-   * Асинхронная валидация в процессе?
-   *
-   * Computed signal. Возвращает true, если хотя бы одно поле находится в pending состоянии.
-   */
-  pending;
-  /**
-   * Все ошибки валидации
-   *
-   * Computed signal. Возвращает массив всех ошибок:
-   * - Form-level errors
-   * - Field-level errors (из всех вложенных полей)
-   */
-  errors;
-  /**
-   * Общий статус формы
-   *
-   * Computed signal. Возможные значения:
-   * - 'disabled' - форма disabled
-   * - 'pending' - асинхронная валидация в процессе
-   * - 'invalid' - форма невалидна
-   * - 'valid' - форма валидна
-   */
-  status;
-  /**
-   * Форма в процессе отправки?
-   *
-   * Computed signal (обертка над _submitting для read-only доступа).
-   */
-  submitting;
-  // ============================================================================
-  // Публичные методы для управления состоянием
-  // ============================================================================
-  /**
-   * Установить form-level ошибки
-   *
-   * @param errors - массив ошибок валидации
-   *
-   * @example
-   * ```typescript
-   * // Server-side ошибки
-   * stateManager.setFormErrors([
-   *   { code: 'server_error', message: 'Пользователь с таким email уже существует' }
-   * ]);
-   * ```
-   */
-  setFormErrors(t) {
-    this._formErrors.value = t;
-  }
-  /**
-   * Очистить form-level ошибки
-   */
-  clearFormErrors() {
-    this._formErrors.value = [];
-  }
-  /**
-   * Получить form-level ошибки
-   */
-  getFormErrors() {
-    return this._formErrors.value;
-  }
-  /**
-   * Установить флаг submitting
-   *
-   * @param value - true если форма отправляется, false если нет
-   *
-   * @example
-   * ```typescript
-   * stateManager.setSubmitting(true);
-   * await api.submitForm(form.getValue());
-   * stateManager.setSubmitting(false);
-   * ```
-   */
-  setSubmitting(t) {
-    this._submitting.value = t;
-  }
-  /**
-   * Установить флаг disabled
-   *
-   * @param value - true если форма disabled, false если нет
-   */
-  setDisabled(t) {
-    this._disabled.value = t;
-  }
-  /**
-   * Получить флаг disabled
-   */
-  isDisabled() {
-    return this._disabled.value;
-  }
-}
-class y extends g {
-  // ============================================================================
-  // Приватные поля
-  // ============================================================================
-  id = k();
-  /**
-   * Реестр полей формы
-   * Использует FieldRegistry для инкапсуляции логики управления коллекцией полей
-   */
-  fieldRegistry;
-  /**
-   * Строитель Proxy для типобезопасного доступа к полям
-   * Использует ProxyBuilder для создания Proxy с расширенной функциональностью
-   */
-  proxyBuilder;
-  /**
-   * Менеджер состояния формы
-   * Инкапсулирует всю логику создания и управления сигналами состояния
-   * Извлечен из GroupNode для соблюдения SRP
-   */
-  stateManager;
-  /**
-   * Менеджер подписок для централизованного cleanup
-   * Использует SubscriptionManager вместо массива для управления подписками
-   */
-  disposers = new _();
-  /**
-   * Ссылка на Proxy-инстанс для использования в BehaviorContext
-   * Устанавливается в конструкторе до применения behavior schema
-   */
-  _proxyInstance;
-  /**
-   * Навигатор для работы с путями к полям
-   * Использует композицию вместо дублирования логики парсинга путей
-   */
-  pathNavigator = new B();
-  /**
-   * Фабрика для создания узлов формы
-   * Использует композицию для централизованного создания FieldNode/GroupNode/ArrayNode
-   */
-  nodeFactory = new G();
-  /**
-   * Реестр валидаторов для этой формы
-   * Использует композицию вместо глобального Singleton
-   * Обеспечивает полную изоляцию форм друг от друга
-   */
-  validationRegistry = new A();
-  /**
-   * Реестр behaviors для этой формы
-   * Использует композицию вместо глобального Singleton
-   * Обеспечивает полную изоляцию форм друг от друга
-   */
-  behaviorRegistry = new F();
-  /**
-   * Аппликатор для применения валидаторов к форме
-   * Извлечен из GroupNode для соблюдения SRP
-   * Использует композицию для управления процессом валидации
-   */
-  validationApplicator = new T(this);
-  /**
-   * Аппликатор для применения behavior схемы к форме
-   * Извлечен из GroupNode для соблюдения SRP
-   * Использует композицию для управления процессом применения behaviors
-   */
-  behaviorApplicator = new D(this, this.behaviorRegistry);
-  // ============================================================================
-  // Публичные computed signals (делегированы в StateManager)
-  // ============================================================================
-  value;
-  valid;
-  invalid;
-  touched;
-  dirty;
-  pending;
-  errors;
-  status;
-  submitting;
-  constructor(t) {
-    super(), this.fieldRegistry = new O(), this.proxyBuilder = new C(this.fieldRegistry);
-    const e = "form" in t, i = e ? t.form : t, s = e ? t.behavior : void 0, a = e ? t.validation : void 0;
-    for (const [o, h] of Object.entries(i)) {
-      const u = this.createNode(h);
-      this.fieldRegistry.set(o, u);
-    }
-    this.stateManager = new $(this.fieldRegistry), this.value = this.stateManager.value, this.valid = this.stateManager.valid, this.invalid = this.stateManager.invalid, this.touched = this.stateManager.touched, this.dirty = this.stateManager.dirty, this.pending = this.stateManager.pending, this.errors = this.stateManager.errors, this.status = this.stateManager.status, this.submitting = this.stateManager.submitting;
-    const n = this.proxyBuilder.build(this);
-    return this._proxyInstance = n, s && this.applyBehaviorSchema(s), a && this.applyValidationSchema(a), n;
-  }
-  // ============================================================================
-  // Реализация абстрактных методов FormNode
-  // ============================================================================
-  getValue() {
-    const t = {};
-    return this.fieldRegistry.forEach((e, i) => {
-      t[i] = e.getValue();
-    }), t;
-  }
-  setValue(t, e) {
-    for (const [i, s] of Object.entries(t)) {
-      const a = this.fieldRegistry.get(i);
-      a && a.setValue(s, e);
-    }
-  }
-  patchValue(t) {
-    for (const [e, i] of Object.entries(t)) {
-      const s = this.fieldRegistry.get(e);
-      s && i !== void 0 && s.setValue(i);
-    }
-  }
-  /**
-   * Сбросить форму к указанным значениям (или к initialValues)
-   *
-   * @param value - опциональный объект со значениями для сброса
-   *
-   * @remarks
-   * Рекурсивно вызывает reset() для всех полей формы
-   *
-   * @example
-   * ```typescript
-   * // Сброс к initialValues
-   * form.reset();
-   *
-   * // Сброс к новым значениям
-   * form.reset({ email: 'new@mail.com', password: '' });
-   * ```
-   */
-  reset(t) {
-    this.fieldRegistry.forEach((e, i) => {
-      const s = t?.[i];
-      e.reset(s);
-    });
-  }
-  /**
-   * Сбросить форму к исходным значениям (initialValues)
-   *
-   * @remarks
-   * Рекурсивно вызывает resetToInitial() для всех полей формы.
-   * Более явный способ сброса к начальным значениям по сравнению с reset()
-   *
-   * Полезно когда:
-   * - Пользователь нажал "Cancel" - полная отмена изменений
-   * - Форма была изменена через reset(newValues), но нужно вернуться к самому началу
-   * - Явное намерение показать "отмена всех изменений"
-   *
-   * @example
-   * ```typescript
-   * const form = new GroupNode({
-   *   email: { value: 'initial@mail.com', component: Input },
-   *   name: { value: 'John', component: Input }
-   * });
-   *
-   * form.email.setValue('changed@mail.com');
-   * form.reset({ email: 'temp@mail.com', name: 'Jane' });
-   * console.log(form.getValue()); // { email: 'temp@mail.com', name: 'Jane' }
-   *
-   * form.resetToInitial();
-   * console.log(form.getValue()); // { email: 'initial@mail.com', name: 'John' }
-   * ```
-   */
-  resetToInitial() {
-    this.fieldRegistry.forEach((t) => {
-      "resetToInitial" in t && typeof t.resetToInitial == "function" ? t.resetToInitial() : t.reset();
-    });
-  }
-  async validate() {
-    this.clearErrors(), await Promise.all(Array.from(this.fieldRegistry.values()).map((e) => e.validate()));
-    const t = this.validationRegistry.getValidators();
-    return t && t.length > 0 && await this.applyContextualValidators(t), Array.from(this.fieldRegistry.values()).every((e) => e.valid.value);
-  }
-  /**
-   * Установить form-level validation errors
-   * Используется для server-side validation или кросс-полевых ошибок
-   *
-   * @param errors - массив ошибок уровня формы
-   *
-   * @example
-   * ```typescript
-   * // Server-side validation после submit
-   * try {
-   *   await api.createUser(form.getValue());
-   * } catch (error) {
-   *   form.setErrors([
-   *     { code: 'duplicate_email', message: 'Email уже используется' }
-   *   ]);
-   * }
-   * ```
-   */
-  setErrors(t) {
-    this.stateManager.setFormErrors(t);
-  }
-  /**
-   * Очистить все errors (form-level + field-level)
-   */
-  clearErrors() {
-    this.stateManager.clearFormErrors(), this.fieldRegistry.forEach((t) => t.clearErrors());
-  }
-  /**
-   * Получить поле по ключу
-   *
-   * Публичный метод для доступа к полю из fieldRegistry
-   *
-   * @param key - Ключ поля
-   * @returns FormNode или undefined, если поле не найдено
-   *
-   * @example
-   * ```typescript
-   * const emailField = form.getField('email');
-   * if (emailField) {
-   *   console.log(emailField.value.value);
-   * }
-   * ```
-   */
-  getField(t) {
-    return this.fieldRegistry.get(t);
-  }
-  /**
-   * Получить Map всех полей формы
-   *
-   * Используется в FieldPathNavigator для навигации по полям
-   *
-   * @returns Map полей формы
-   */
-  get fields() {
-    return this.fieldRegistry;
-  }
-  /**
-   * Получить 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;
-  }
-  /**
-   * Получить все поля формы как итератор
-   *
-   * Предоставляет доступ к внутренним полям для валидации и других операций
-   *
-   * @returns Итератор по всем полям формы
-   *
-   * @example
-   * ```typescript
-   * // Валидация всех полей
-   * await Promise.all(
-   *   Array.from(form.getAllFields()).map(field => field.validate())
-   * );
-   * ```
-   */
-  getAllFields() {
-    return this.fieldRegistry.values();
-  }
-  // ============================================================================
-  // Protected hooks (Template Method pattern)
-  // ============================================================================
-  /**
-   * Hook: вызывается после markAsTouched()
-   *
-   * Для GroupNode: рекурсивно помечаем все дочерние поля как touched
-   */
-  onMarkAsTouched() {
-    this.fieldRegistry.forEach((t) => t.markAsTouched());
-  }
-  /**
-   * Hook: вызывается после markAsUntouched()
-   *
-   * Для GroupNode: рекурсивно помечаем все дочерние поля как untouched
-   */
-  onMarkAsUntouched() {
-    this.fieldRegistry.forEach((t) => t.markAsUntouched());
-  }
-  /**
-   * Hook: вызывается после markAsDirty()
-   *
-   * Для GroupNode: рекурсивно помечаем все дочерние поля как dirty
-   */
-  onMarkAsDirty() {
-    this.fieldRegistry.forEach((t) => t.markAsDirty());
-  }
-  /**
-   * Hook: вызывается после markAsPristine()
-   *
-   * Для GroupNode: рекурсивно помечаем все дочерние поля как pristine
-   */
-  onMarkAsPristine() {
-    this.fieldRegistry.forEach((t) => t.markAsPristine());
-  }
-  // ============================================================================
-  // Дополнительные методы (из FormStore)
-  // ============================================================================
-  /**
-   * Отправить форму
-   * Валидирует форму и вызывает onSubmit если форма валидна
-   */
-  async submit(t) {
-    if (this.markAsTouched(), !await this.validate())
-      return null;
-    this.stateManager.setSubmitting(!0);
-    try {
-      return await t(this.getValue());
-    } finally {
-      this.stateManager.setSubmitting(!1);
-    }
-  }
-  /**
-   * Применить validation schema к форме
-   *
-   * Использует локальный реестр валидаторов (this.validationRegistry)
-   * вместо глобального Singleton для изоляции форм друг от друга.
-   */
-  applyValidationSchema(t) {
-    this.validationRegistry.beginRegistration();
-    try {
-      const e = S();
-      t(e);
-      const i = this.getProxy();
-      this.validationRegistry.endRegistration(i);
-    } catch (e) {
-      throw console.error("Error applying validation schema:", e), e;
-    }
-  }
-  /**
-   * Применить behavior schema к форме
-   *
-   * ✅ РЕФАКТОРИНГ: Делегирование BehaviorApplicator (SRP)
-   *
-   * Логика применения behavior схемы извлечена в BehaviorApplicator для:
-   * - Соблюдения Single Responsibility Principle
-   * - Уменьшения размера GroupNode (~50 строк)
-   * - Улучшения тестируемости
-   * - Консистентности с ValidationApplicator
-   *
-   * @param schemaFn Функция описания поведения формы
-   * @returns Функция cleanup для отписки от всех behaviors
-   *
-   * @example
-   * ```typescript
-   * import { copyFrom, enableWhen, computeFrom } from '@/lib/forms/core/behaviors';
-   *
-   * const behaviorSchema: BehaviorSchemaFn<MyForm> = (path) => {
-   *   copyFrom(path.residenceAddress, path.registrationAddress, {
-   *     when: (form) => form.sameAsRegistration === true
-   *   });
-   *
-   *   enableWhen(path.propertyValue, (form) => form.loanType === 'mortgage');
-   *
-   *   computeFrom(
-   *     path.initialPayment,
-   *     [path.propertyValue],
-   *     (propertyValue) => propertyValue ? propertyValue * 0.2 : null
-   *   );
-   * };
-   *
-   * const cleanup = form.applyBehaviorSchema(behaviorSchema);
-   *
-   * // Cleanup при unmount
-   * useEffect(() => cleanup, []);
-   * ```
-   */
-  applyBehaviorSchema(t) {
-    return this.behaviorApplicator.apply(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(t) {
-    if (t.startsWith(".") || t.endsWith("."))
-      return;
-    const e = this.pathNavigator.parsePath(t);
-    if (e.length === 0)
-      return;
-    let i = this;
-    for (const s of e) {
-      if (!(i instanceof y) || (i = i.getField(s.key), !i)) return;
-      if (s.index !== void 0)
-        if ("at" in i && "length" in i && typeof i.at == "function") {
-          const a = i.at(s.index);
-          if (!a) return;
-          i = a;
-        } else
-          return;
-    }
-    return i;
-  }
-  /**
-   * Применить contextual валидаторы к полям
-   *
-   * ✅ РЕФАКТОРИНГ: Делегирование ValidationApplicator (SRP)
-   *
-   * Логика применения валидаторов извлечена в ValidationApplicator для:
-   * - Соблюдения Single Responsibility Principle
-   * - Уменьшения размера GroupNode (~120 строк)
-   * - Улучшения тестируемости
-   *
-   * @param validators Зарегистрированные валидаторы
-   */
-  async applyContextualValidators(t) {
-    await this.validationApplicator.apply(t);
-  }
-  // ============================================================================
-  // Private методы для создания узлов
-  // ============================================================================
-  /**
-   * Создать узел на основе конфигурации
-   *
-   * ✅ РЕФАКТОРИНГ: Полное делегирование NodeFactory
-   *
-   * NodeFactory теперь обрабатывает:
-   * - Массивы [schema, ...items]
-   * - FieldConfig
-   * - GroupConfig
-   * - ArrayConfig
-   *
-   * @param config Конфигурация узла
-   * @returns Созданный узел формы
-   * @private
-   */
-  createNode(t) {
-    return this.nodeFactory.createNode(t);
-  }
-  // ============================================================================
-  // Методы-помощники для реактивности (Фаза 1)
-  // ============================================================================
-  /**
-   * Связывает два поля: при изменении source автоматически обновляется target
-   * Поддерживает опциональную трансформацию значения
-   *
-   * @param sourceKey - Ключ поля-источника
-   * @param targetKey - Ключ поля-цели
-   * @param transform - Опциональная функция трансформации значения
-   * @returns Функция отписки для cleanup
-   *
-   * @example
-   * ```typescript
-   * // Автоматический расчет минимального взноса от стоимости недвижимости
-   * const dispose = form.linkFields(
-   *   'propertyValue',
-   *   'initialPayment',
-   *   (propertyValue) => propertyValue ? propertyValue * 0.2 : null
-   * );
-   *
-   * // При изменении propertyValue → автоматически обновится initialPayment
-   * form.propertyValue.setValue(1000000);
-   * // initialPayment станет 200000
-   *
-   * // Cleanup
-   * useEffect(() => dispose, []);
-   * ```
-   */
-  linkFields(t, e, i) {
-    const s = this.fieldRegistry.get(t), a = this.fieldRegistry.get(e);
-    if (!s || !a)
-      return () => {
-      };
-    const n = c(() => {
-      const h = s.value.value, u = i ? i(h) : h;
-      a.setValue(u, { emitEvent: !1 });
-    }), o = `linkFields-${Date.now()}-${Math.random()}`;
-    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(t, e) {
-    const i = this.getFieldByPath(t);
-    if (!i)
-      return () => {
-      };
-    const s = c(() => {
-      const n = i.value.value;
-      e(n);
-    }), a = `watchField-${Date.now()}-${Math.random()}`;
-    return this.disposers.add(a, s);
-  }
-  /**
-   * Hook: вызывается после disable()
-   *
-   * Для GroupNode: рекурсивно отключаем все дочерние поля
-   */
-  onDisable() {
-    this.stateManager.setDisabled(!0), this.fieldRegistry.forEach((t) => {
-      t.disable();
-    });
-  }
-  /**
-   * Hook: вызывается после enable()
-   *
-   * Для GroupNode: рекурсивно включаем все дочерние поля
-   */
-  onEnable() {
-    this.stateManager.setDisabled(!1), this.fieldRegistry.forEach((t) => {
-      t.enable();
-    });
-  }
-  /**
-   * Очистить все ресурсы узла
-   * Рекурсивно очищает все subscriptions и дочерние узлы
-   *
-   * @example
-   * ```typescript
-   * useEffect(() => {
-   *   return () => {
-   *     form.dispose();
-   *   };
-   * }, []);
-   * ```
-   */
-  dispose() {
-    this.disposers.dispose(), this.fieldRegistry.forEach((t) => {
-      "dispose" in t && typeof t.dispose == "function" && t.dispose();
-    });
-  }
-}
-class G {
-  /**
-   * Создает узел формы на основе конфигурации
-   *
-   * ✅ ОБНОВЛЕНО: Теперь поддерживает массивы напрямую
-   *
-   * Автоматически определяет тип узла:
-   * - 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(t) {
-    if (Array.isArray(t) && t.length >= 1)
-      return this.createArrayNodeFromArray(t);
-    if (this.isFieldConfig(t))
-      return new R(t);
-    if (this.isArrayConfig(t)) {
-      const e = t;
-      return new E(
-        e.schema,
-        e.initialItems
-      );
-    }
-    if (this.isGroupConfig(t))
-      return new y(t);
-    throw new Error(
-      `NodeFactory: Unknown node config. Expected FieldConfig, GroupConfig, or ArrayConfig, but got: ${JSON.stringify(
-        t
-      )}`
-    );
-  }
-  /**
-   * Создать 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(t) {
-    const [e, ...i] = t, s = [];
-    this.isGroupConfig(e) && s.push(this.extractValues(e));
-    for (const a of i)
-      this.isGroupConfig(a) ? s.push(this.extractValues(a)) : s.push(a);
-    return new E(e, s);
-  }
-  /**
-   * Извлечь значения из схемы (рекурсивно)
-   *
-   * ✅ НОВОЕ: Извлечено из 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(t) {
-    if (this.isFieldConfig(t))
-      return t.value;
-    if (Array.isArray(t))
-      return t.map((e) => this.extractValues(e));
-    if (this.isGroupConfig(t)) {
-      const e = {};
-      for (const [i, s] of Object.entries(t))
-        e[i] = this.extractValues(s);
-      return e;
-    }
-    return t;
-  }
-  /**
-   * Проверяет, является ли конфиг конфигурацией поля (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(t) {
-    return t != null && typeof t == "object" && "value" in t && "component" in t;
-  }
-  /**
-   * Проверяет, является ли конфиг конфигурацией массива (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(t) {
-    return t != null && typeof t == "object" && "schema" in t && !("value" in t);
-  }
-  /**
-   * Проверяет, является ли конфиг конфигурацией группы (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(t) {
-    return t != null && typeof t == "object" && !this.isFieldConfig(t) && !this.isArrayConfig(t);
-  }
-}
-export {
-  E as A,
-  v as E,
-  g as F,
-  y as G,
-  G as N,
-  _ as S,
-  I as T,
-  N as V,
-  R as a,
-  B as b,
-  p as c,
-  M as d,
-  P as e,
-  m as f,
-  z as g,
-  x as h,
-  f as i,
-  S as j,
-  K as k,
-  L as t
-};