@reformer/core 10.2.0 → 11.0.0-beta.10

package/dist/index.js

@@ -1,2931 +1,1084 @@
-import { c as Ie } from "./form-model-DYCzGGKF.js";
-import { c as Re, a as Be, r as $e, b as Ge, d as je, e as Ue, f as We, s as qe, t as He, w as Ke } from "./behaviors-value-C7dSEhCc.js";
-import { i as B } from "./derived-registry-CluZCQ7U.js";
-import { m as Ye, u as ze } from "./derived-registry-CluZCQ7U.js";
-import { S as I } from "./subscription-manager-705bls97.js";
-import { default as Xe } from "./validators.js";
-import { signal as g, computed as c, effect as E, batch as X, Signal as $ } from "@preact/signals-core";
-import { r as Z } from "./signal-node-registry-tiwel-TV.js";
-import { g as et } from "./signal-node-registry-tiwel-TV.js";
-import { d as st, e as it } from "./behaviors-node-DGEFMTQu.js";
-import K, { useRef as O, useCallback as _, useMemo as ee, useEffect as te } from "react";
-import { createFormValidation as se } from "./validation.js";
-class M {
-  // ============================================================================
-  // Protected состояние (для Template Method паттерна)
-  // ============================================================================
-  /**
-   * Пользователь взаимодействовал с узлом (touched)
-   * Protected: наследники могут читать/изменять через методы
-   */
-  _touched = g(!1);
-  /**
-   * Значение узла было изменено (dirty)
-   * Protected: наследники могут читать/изменять через методы
-   */
-  _dirty = g(!1);
-  /**
-   * Текущий статус узла
-   * Protected: наследники могут читать/изменять через методы
-   */
-  _status = g("valid");
-  // ============================================================================
-  // Публичные computed signals (readonly для внешнего мира)
-  // ============================================================================
-  /**
-   * Пользователь взаимодействовал с узлом (touched)
-   * Computed из _touched для предоставления readonly интерфейса
-   */
-  touched = c(() => this._touched.value);
-  /**
-   * Пользователь не взаимодействовал с узлом (untouched)
-   */
-  untouched = c(() => !this._touched.value);
-  /**
-   * Значение узла было изменено (dirty)
-   * Computed из _dirty для предоставления readonly интерфейса
-   */
-  dirty = c(() => this._dirty.value);
-  /**
-   * Значение узла не было изменено (pristine)
-   */
-  pristine = c(() => !this._dirty.value);
-  /**
-   * Текущий статус узла
-   * Computed из _status для предоставления readonly интерфейса
-   */
-  status = c(() => this._status.value);
-  /**
-   * Узел отключен (disabled)
-   */
-  disabled = c(() => this._status.value === "disabled");
-  /**
-   * Узел включен (enabled)
-   */
-  enabled = c(() => this._status.value !== "disabled");
-  /**
-   * Получить ошибки валидации с фильтрацией
-   *
-   * Позволяет фильтровать ошибки по различным критериям:
-   * - По коду ошибки
-   * - По сообщению (частичное совпадение)
-   * - По параметрам
-   * - Через кастомный предикат
-   *
-   * Без параметров возвращает все ошибки (эквивалент errors.value)
-   *
-   * @param options - Опции фильтрации ошибок
-   * @returns Отфильтрованный массив ошибок валидации
-   *
-   * @example
-   * ```typescript
-   * // Все ошибки
-   * const allErrors = form.getErrors();
-   *
-   * // Ошибки с конкретным кодом
-   * const requiredErrors = form.getErrors({ code: 'required' });
-   *
-   * // Ошибки с несколькими кодами
-   * const errors = form.getErrors({ code: ['required', 'email'] });
-   *
-   * // Ошибки по сообщению
-   * const passwordErrors = form.getErrors({ message: 'Password' });
-   *
-   * // Ошибки по параметрам
-   * const minLengthErrors = form.getErrors({
-   *   params: { minLength: 8 }
-   * });
-   *
-   * // Кастомная фильтрация
-   * const customErrors = form.getErrors({
-   *   predicate: (err) => err.code.startsWith('custom_')
-   * });
-   * ```
-   */
-  getErrors(e) {
-    const t = this.errors.value;
-    return e ? t.filter((s) => {
-      if (e.code !== void 0 && !(Array.isArray(e.code) ? e.code : [e.code]).includes(s.code) || e.message !== void 0 && !s.message.toLowerCase().includes(e.message.toLowerCase()))
-        return !1;
-      if (e.params !== void 0) {
-        if (!s.params)
-          return !1;
-        for (const [i, a] of Object.entries(e.params))
-          if (s.params[i] !== a)
-            return !1;
-      }
-      return !(e.predicate !== void 0 && !e.predicate(s));
-    }) : t;
-  }
-  // ============================================================================
-  // Методы управления состоянием (Template Method)
-  // ============================================================================
-  /**
-   * Отметить узел как touched (пользователь взаимодействовал)
-   *
-   * Template Method: обновляет signal в базовом классе,
-   * вызывает hook для кастомной логики в наследниках
-   */
-  markAsTouched() {
-    this._touched.value = !0, this.onMarkAsTouched();
-  }
-  /**
-   * Отметить узел как untouched
-   *
-   * Template Method: обновляет signal в базовом классе,
-   * вызывает hook для кастомной логики в наследниках
-   */
-  markAsUntouched() {
-    this._touched.value = !1, this.onMarkAsUntouched();
-  }
-  /**
-   * Отметить узел как dirty (значение изменено)
-   *
-   * Template Method: обновляет signal в базовом классе,
-   * вызывает hook для кастомной логики в наследниках
-   */
-  markAsDirty() {
-    this._dirty.value = !0, this.onMarkAsDirty();
-  }
-  /**
-   * Отметить узел как pristine (значение не изменено)
-   *
-   * Template Method: обновляет signal в базовом классе,
-   * вызывает hook для кастомной логики в наследниках
-   */
-  markAsPristine() {
-    this._dirty.value = !1, this.onMarkAsPristine();
-  }
-  /**
-   * Пометить все поля (включая вложенные) как touched
-   * Алиас для markAsTouched(), но более явно показывает намерение
-   * пометить ВСЕ поля рекурсивно
-   *
-   * Полезно для:
-   * - Показа всех ошибок валидации перед submit
-   * - Принудительного отображения ошибок при нажатии "Validate All"
-   * - Отображения невалидных полей в wizard/step form
-   *
-   * @example
-   * ```typescript
-   * // Показать все ошибки перед submit
-   * form.touchAll();
-   * const isValid = await form.validate();
-   * if (!isValid) {
-   *   // Все ошибки теперь видны пользователю
-   * }
-   *
-   * // Или использовать submit() который уже вызывает touchAll
-   * await form.submit(async (values) => {
-   *   await api.save(values);
-   * });
-   * ```
-   */
-  touchAll() {
-    this.markAsTouched();
-  }
-  // ============================================================================
-  // Методы управления доступностью (Template Method)
-  // ============================================================================
-  /**
-   * Отключить узел
-   *
-   * Template Method: обновляет статус в базовом классе,
-   * вызывает hook для кастомной логики в наследниках
-   *
-   * Отключенные узлы не проходят валидацию и не включаются в getValue()
-   */
-  disable() {
-    this._status.value = "disabled", this.onDisable();
-  }
-  /**
-   * Включить узел
-   *
-   * Template Method: обновляет статус в базовом классе,
-   * вызывает hook для кастомной логики в наследниках
-   */
-  enable() {
-    this._status.value = "valid", this.onEnable();
-  }
-  // ============================================================================
-  // Protected hooks (для переопределения в наследниках)
-  // ============================================================================
-  /**
-   * Hook: вызывается после markAsTouched()
-   *
-   * Переопределите в наследниках для дополнительной логики:
-   * - GroupNode: пометить все дочерние узлы как touched
-   * - ArrayNode: пометить все элементы массива как touched
-   * - FieldNode: пустая реализация (нет дочерних узлов)
-   *
-   * @example
-   * ```typescript
-   * // GroupNode
-   * protected onMarkAsTouched(): void {
-   *   this.fields.forEach(field => field.markAsTouched());
-   * }
-   * ```
-   */
-  onMarkAsTouched() {
-  }
-  /**
-   * Hook: вызывается после markAsUntouched()
-   *
-   * Переопределите в наследниках для дополнительной логики:
-   * - GroupNode: пометить все дочерние узлы как untouched
-   * - ArrayNode: пометить все элементы массива как untouched
-   * - FieldNode: пустая реализация (нет дочерних узлов)
-   */
-  onMarkAsUntouched() {
-  }
-  /**
-   * Hook: вызывается после markAsDirty()
-   *
-   * Переопределите в наследниках для дополнительной логики:
-   * - GroupNode: может обновить родительскую форму
-   * - ArrayNode: может обновить родительскую форму
-   * - FieldNode: пустая реализация
-   */
-  onMarkAsDirty() {
-  }
-  /**
-   * Hook: вызывается после markAsPristine()
-   *
-   * Переопределите в наследниках для дополнительной логики:
-   * - GroupNode: пометить все дочерние узлы как pristine
-   * - ArrayNode: пометить все элементы массива как pristine
-   * - FieldNode: пустая реализация
-   */
-  onMarkAsPristine() {
-  }
-  /**
-   * Hook: вызывается после disable()
-   *
-   * Переопределите в наследниках для дополнительной логики:
-   * - GroupNode: отключить все дочерние узлы
-   * - ArrayNode: отключить все элементы массива
-   * - FieldNode: очистить ошибки валидации
-   *
-   * @example
-   * ```typescript
-   * // GroupNode
-   * protected onDisable(): void {
-   *   this.fields.forEach(field => field.disable());
-   * }
-   * ```
-   */
-  onDisable() {
-  }
-  /**
-   * Hook: вызывается после enable()
-   *
-   * Переопределите в наследниках для дополнительной логики:
-   * - GroupNode: включить все дочерние узлы
-   * - ArrayNode: включить все элементы массива
-   * - FieldNode: пустая реализация
-   */
-  onEnable() {
-  }
+import { c as ue } from "./create-model-DPSG3I0O.js";
+import { e as vt, a as pt } from "./create-model-DPSG3I0O.js";
+import { d as T, q as H, t as de, o as he, n as fe, b as J, m as _, i as X, v as ve, w as pe, p as me, f as we, g as ye, x as be } from "./safe-effect-BazLOv1g.js";
+import { a as wt, c as yt, r as bt, s as gt, e as kt, u as St } from "./safe-effect-BazLOv1g.js";
+import { signal as w, computed as d, batch as D, effect as ge, untracked as A } from "@preact/signals-core";
+import { N as j, R as ke, k as Se, r as k } from "./node-kind-C-r6ZMdo.js";
+import { r as O } from "./signal-node-registry-tiwel-TV.js";
+import { g as Et } from "./signal-node-registry-tiwel-TV.js";
+import { c as $e, u as Ee } from "./schema-controller-CpiO2JoK.js";
+import { a as At } from "./schema-controller-CpiO2JoK.js";
+import { e as Pe, h as Ae, i as Oe, c as Fe, j as Ie } from "./strategy-DzvnsWLh.js";
+import { c as Ft, a as It, b as Nt, i as Vt } from "./type-guards-D-N_5Ddh.js";
+function Ne() {
+  const t = w(!1), e = w(!1), s = w(0);
+  return {
+    touched: d(() => t.value),
+    dirty: d(() => e.value),
+    touches: d(() => s.value),
+    setTouched: (i) => {
+      D(() => {
+        t.value = i, i && (s.value = s.peek() + 1);
+      });
+    },
+    setDirty: (i) => {
+      e.value = i;
+    }
+  };
 }
-const w = {
-  /** FieldNode.watch() */
-  Watch: "watch",
-  /** FieldNode.computeFrom() */
-  ComputeFrom: "computeFrom",
-  /** GroupNode.linkFields() */
-  LinkFields: "linkFields",
-  /** GroupNode.watchField() */
-  WatchField: "watchField",
-  /** ArrayNode.watchItems() */
-  WatchItems: "watchItems",
-  /** ArrayNode.watchLength() */
-  WatchLength: "watchLength"
-};
-let ie = 0;
-function V(r) {
-  return `${r}-${++ie}`;
+function R() {
+  const t = w([]);
+  return {
+    list: d(() => t.value),
+    blocking: d(() => t.value.some((e) => e.severity !== "warning")),
+    set: (e) => {
+      t.value = e;
+    },
+    clear: () => {
+      t.value = [];
+    }
+  };
 }
-var A = /* @__PURE__ */ ((r) => (r.THROW = "throw", r.LOG = "log", r.CONVERT = "convert", r))(A || {});
-class F {
-  static handle(e, t, s = "throw") {
-    const i = this.extractMessage(e);
-    switch (process.env.NODE_ENV !== "production" && console.error(`[${t}]`, e), s) {
-      case "throw":
-        throw e;
-      case "log":
-        return;
-      case "convert":
-        return {
-          code: "validator_error",
-          message: i,
-          params: { field: t }
-        };
+function K(t = !1) {
+  const e = w(t);
+  return {
+    disabled: d(() => e.value),
+    setDisabled: (s) => {
+      e.value = s;
     }
-  }
-  /**
-   * Извлечь сообщение из ошибки
-   *
-   * Обрабатывает различные типы ошибок:
-   * - 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(e) {
-    return e instanceof Error ? e.message : typeof e == "string" ? e : typeof e == "object" && e !== null && "message" in e ? String(e.message) : String(e);
-  }
-  /**
-   * Создать 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(e, t, s) {
-    return {
-      code: e,
-      message: t,
-      params: s ? { field: s } : 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(e) {
-    return typeof e == "object" && e !== null && "code" in e && "message" in e && typeof e.code == "string" && typeof e.message == "string";
-  }
+  };
 }
-class re {
-  /** Внутренний сигнал статуса */
-  _status;
-  /** Публичный read-only сигнал статуса */
-  status;
-  /** Поле валидно */
-  valid;
-  /** Поле невалидно */
-  invalid;
-  /** Идет валидация */
-  pending;
-  /** Поле отключено */
-  disabled;
-  /**
-   * @param initial - Начальный статус (по умолчанию 'valid')
-   */
-  constructor(e = "valid") {
-    this._status = g(e), this.status = c(() => this._status.value), this.valid = c(() => this._status.value === "valid"), this.invalid = c(() => this._status.value === "invalid"), this.pending = c(() => this._status.value === "pending"), this.disabled = c(() => this._status.value === "disabled");
-  }
-  /**
-   * Начать валидацию
-   *
-   * Переводит статус в 'pending' если поле не отключено
-   *
-   * @example
-   * ```typescript
-   * statusMachine.startValidation();
-   * // status: 'pending'
-   * ```
-   */
-  startValidation() {
-    this._status.value !== "disabled" && (this._status.value = "pending");
-  }
-  /**
-   * Завершить валидацию
-   *
-   * @param hasErrors - Есть ли ошибки валидации
-   *
-   * @example
-   * ```typescript
-   * // Валидация успешна
-   * statusMachine.completeValidation(false);
-   * // status: 'valid'
-   *
-   * // Есть ошибки
-   * statusMachine.completeValidation(true);
-   * // status: 'invalid'
-   * ```
-   */
-  completeValidation(e) {
-    this._status.value !== "disabled" && (this._status.value = e ? "invalid" : "valid");
-  }
-  /**
-   * Установить ошибки напрямую (без перехода через pending)
-   *
-   * Используется для синхронной валидации или установки ошибок извне
-   *
-   * @param hasErrors - Есть ли ошибки
-   *
-   * @example
-   * ```typescript
-   * statusMachine.setErrors(true);
-   * // status: 'invalid'
-   * ```
-   */
-  setErrors(e) {
-    this._status.value !== "disabled" && (this._status.value = e ? "invalid" : "valid");
-  }
-  /**
-   * Отключить поле
-   *
-   * Переводит статус в 'disabled'
-   *
-   * @example
-   * ```typescript
-   * statusMachine.disable();
-   * // status: 'disabled'
-   * ```
-   */
-  disable() {
-    this._status.value = "disabled";
-  }
-  /**
-   * Включить поле
-   *
-   * @param hasErrors - Есть ли ошибки (определяет valid/invalid)
-   *
-   * @example
-   * ```typescript
-   * statusMachine.enable(false);
-   * // status: 'valid'
-   *
-   * statusMachine.enable(true);
-   * // status: 'invalid'
-   * ```
-   */
-  enable(e = !1) {
-    this._status.value = e ? "invalid" : "valid";
-  }
-  /**
-   * Обработать событие (альтернативный API)
-   *
-   * @param event - Событие для обработки
-   *
-   * @example
-   * ```typescript
-   * statusMachine.dispatch({ type: 'START_VALIDATION' });
-   * statusMachine.dispatch({ type: 'VALIDATION_FAILURE' });
-   * ```
-   */
-  dispatch(e) {
-    switch (e.type) {
-      case "START_VALIDATION":
-        this.startValidation();
-        break;
-      case "VALIDATION_SUCCESS":
-        this.completeValidation(!1);
-        break;
-      case "VALIDATION_FAILURE":
-        this.completeValidation(!0);
-        break;
-      case "DISABLE":
-        this.disable();
-        break;
-      case "ENABLE":
-        this.enable(e.hasErrors);
-        break;
-      case "SET_ERRORS":
-        this.setErrors(e.hasErrors);
-        break;
+function W() {
+  const t = w(0);
+  return {
+    active: d(() => t.value > 0),
+    mark: (e) => {
+      t.value = Math.max(0, t.peek() + (e ? 1 : -1));
     }
-  }
-  /**
-   * Получить текущий статус
-   */
-  getStatus() {
-    return this._status.value;
-  }
-  /**
-   * Проверить, можно ли начать валидацию
-   */
-  canValidate() {
-    return this._status.value !== "disabled";
-  }
+  };
 }
-class ae extends M {
-  // ============================================================================
-  // Приватные сигналы
-  // ============================================================================
-  _value;
-  _errors;
-  // _touched, _dirty наследуются от FormNode (protected)
-  // _status управляется через statusMachine
-  _componentProps;
-  /**
-   * State machine для управления статусом поля
-   * Централизует логику переходов между valid/invalid/pending/disabled
-   */
-  statusMachine;
-  // ============================================================================
-  // Публичные computed signals
-  // ============================================================================
+function Ve(t = {}) {
+  const e = w(t);
+  return {
+    props: d(() => e.value),
+    update: (s) => {
+      e.value = { ...e.peek(), ...s };
+    }
+  };
+}
+class Ce {
+  [j] = "control";
   value;
-  // valid, invalid, pending, status, disabled берутся из statusMachine
   valid;
   invalid;
   pending;
-  // Override status и disabled из базового класса
-  status;
   disabled;
-  // touched, dirty наследуются от FormNode
-  errors;
+  touched;
+  /** Уходы из поля, включая повторные, — триггер стратегии `blur`. @internal */
+  touches;
+  dirty;
+  issues;
+  ownIssues;
+  component;
   componentProps;
-  /**
-   * Вычисляемое свойство: нужно ли показывать ошибку
-   * Ошибка показывается если поле невалидно И (touched ИЛИ dirty)
-   */
   shouldShowError;
-  // ============================================================================
-  // Конфигурация
-  // ============================================================================
-  validators;
-  asyncValidators;
-  updateOn;
-  initialValue;
-  currentAbortController;
-  debounceMs;
-  validateDebounceTimer;
+  shouldShowIssues;
+  source;
   /**
-   * Pending debounced validation state
-   * Contains resolve function and AbortController for cancellation
+   * Значение на момент построения. К нему возвращает `resetToCreation` (`resetOnDisable`), а
+   * {@link reset} — только поле над собственным сигналом, без модели за ним.
    */
-  pendingValidation;
+  initialValue;
+  interaction = Ne();
+  issueState = R();
+  availability;
   /**
-   * Менеджер подписок для централизованного cleanup
-   * Использует SubscriptionManager вместо массива для управления подписками
+   * Блокировка из схемы (`disabled: true` узла — вычисляемые `total`, `fullName`). Постоянная:
+   * `enable()` контейнера её не снимает, иначе «выключить форму на время отправки → включить»
+   * разблокировало бы такие поля. Снимает её только явный `enable()` этого поля.
    */
-  disposers = new I();
-  component;
-  // ============================================================================
-  // Конструктор
-  // ============================================================================
+  locked;
+  pendingState = W();
+  componentState;
   constructor(e) {
-    super(), this.validators = e.validators || [], this.asyncValidators = e.asyncValidators || [], this.updateOn = e.updateOn || "blur", this.debounceMs = e.debounce || 0, this.component = e.component, this._value = e.valueSignal ?? g(e.value), this.initialValue = this._value.peek(), this._errors = g([]), this._componentProps = g(e.componentProps || {}), this.statusMachine = new re(e.disabled ? "disabled" : "valid"), this.value = c(() => this._value.value), this.valid = c(() => this.statusMachine.valid.value), this.invalid = c(() => this.statusMachine.invalid.value), this.pending = c(() => this.statusMachine.pending.value), this.status = c(() => this.statusMachine.status.value), this.disabled = c(() => this.statusMachine.disabled.value), this.errors = c(() => this._errors.value), this.componentProps = c(() => this._componentProps.value), this.shouldShowError = c(
-      () => this.statusMachine.invalid.value && (this._touched.value || this._dirty.value)
+    this.source = e.valueSignal, this.initialValue = this.source.peek(), this.component = e.component, this.availability = K(e.disabled === !0), this.locked = e.disabled === !0, this.componentState = Ve(e.componentProps ?? {});
+    const { disabled: s } = this.availability, i = this.issueState.blocking;
+    this.value = d(() => this.source.value), this.disabled = s, this.pending = d(() => !s.value && this.pendingState.active.value), this.invalid = d(() => !s.value && !this.pending.value && i.value), this.valid = d(() => !s.value && !this.pending.value && !i.value), this.touched = this.interaction.touched, this.touches = this.interaction.touches, this.dirty = this.interaction.dirty, this.issues = this.issueState.list, this.ownIssues = this.issueState.list, this.componentProps = this.componentState.props;
+    const n = d(() => this.touched.value || this.dirty.value);
+    this.shouldShowError = d(() => this.invalid.value && n.value), this.shouldShowIssues = d(
+      () => !s.value && !this.pending.value && this.issues.value.length > 0 && n.value
     );
   }
-  // ============================================================================
-  // Реализация абстрактных методов FormNode
-  // ============================================================================
   getValue() {
-    return this._value.peek();
-  }
-  setValue(e, t) {
-    if (this._value.value = e, this._dirty.value = !0, t?.emitEvent === !1)
-      return;
-    const s = this.validators.length > 0 || this.asyncValidators.length > 0, i = this._errors.value.length > 0;
-    if (this.updateOn === "change") {
-      this.validate();
-      return;
-    }
-    i && s && this.validate();
+    return this.source.peek();
   }
-  patchValue(e) {
-    this.setValue(e);
+  setValue(e) {
+    this.source.value = e, this.interaction.setDirty(!0);
   }
   /**
-   * Сбросить поле к указанному значению (или к initialValue)
-   *
-   * @param value - опциональное значение для сброса. Если не указано, используется initialValue
-   *
-   * @remarks
-   * Этот метод:
-   * - Устанавливает значение в value или initialValue
-   * - Очищает ошибки валидации
-   * - Сбрасывает touched/dirty флаги
-   * - Устанавливает статус в 'valid'
-   *
-   * Если вам нужно сбросить к исходному значению, используйте resetToInitial()
+   * Сбросить поле: значение, замечания, `touched` и `dirty`. Без аргумента — к точке отсчёта модели,
+   * той же, к которой возвращает `model.reset()`: значению создания модели либо последнему
+   * `captureInitial()` (загруженные данные). Поле над собственным сигналом, без модели, — к значению,
+   * с которым нода создана.
    *
-   * @example
-   * ```typescript
-   * // Сброс к initialValue
-   * field.reset();
-   *
-   * // Сброс к новому значению
-   * field.reset('new value');
-   * ```
+   * У производного поля (цель `compute`) без аргумента сбрасывается только состояние: значением
+   * владеет поведение, а значение создания ноды снято до первого расчёта — запись вернула бы
+   * «сырое» значение, которое `compute` пересчитает лишь при смене источников.
    */
   reset(e) {
-    this._value.value = e !== void 0 ? e : this.initialValue, this._errors.value = [], this._touched.value = !1, this._dirty.value = !1, this.statusMachine.setErrors(!1);
+    e !== void 0 ? this.source.value = e : T(this.source) || (this.source.value = this.referenceValue()), this.resetState();
   }
-  /**
-   * Сбросить поле к исходному значению (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);
+  /** Точка отсчёта модели за полем; у поля без модели — значение создания. */
+  referenceValue() {
+    const e = H(this.source);
+    return e === void 0 ? this.initialValue : e.value;
   }
-  /**
-   * Cancel any pending validation (debounced or running)
-   * @private
-   * @remarks
-   * Centralizes all cancellation logic:
-   * - Aborts pending debounced validation and resolves its promise
-   * - Clears debounce timer
-   * - Aborts currently running async validation
-   */
-  cancelPendingValidation() {
-    this.pendingValidation && (this.pendingValidation.abortController.abort(), this.pendingValidation.resolve(!1), this.pendingValidation = void 0), this.validateDebounceTimer && (clearTimeout(this.validateDebounceTimer), this.validateDebounceTimer = void 0), this.currentAbortController && (this.currentAbortController.abort(), this.currentAbortController = void 0);
+  /** Значение создания и чистое состояние, у цели `compute` тоже — для `resetOnDisable`. @internal */
+  resetToCreation() {
+    this.source.value = this.initialValue, this.resetState();
   }
-  /**
-   * Запустить валидацию поля
-   * @param options - опции валидации
-   * @returns `Promise<boolean>` - true если поле валидно
-   *
-   * @remarks
-   * Метод защищен от race conditions через AbortController.
-   * При быстром вводе только последняя валидация применяет результаты.
-   *
-   * @example
-   * ```typescript
-   * // Обычная валидация
-   * await field.validate();
-   *
-   * // С debounce
-   * await field.validate({ debounce: 300 });
-   * ```
-   */
-  async validate(e) {
-    const t = e?.debounce ?? this.debounceMs;
-    if (this.cancelPendingValidation(), t <= 0 || this.asyncValidators.length === 0)
-      return this.validateImmediate();
-    const s = new AbortController();
-    return new Promise((i) => {
-      this.pendingValidation = { resolve: i, abortController: s }, this.validateDebounceTimer = setTimeout(async () => {
-        if (this.validateDebounceTimer = void 0, s.signal.aborted) {
-          i(!1);
-          return;
-        }
-        this.pendingValidation = void 0;
-        const a = await this.validateImmediate(s);
-        i(a);
-      }, t), s.signal.addEventListener(
-        "abort",
-        () => {
-          this.validateDebounceTimer && (clearTimeout(this.validateDebounceTimer), this.validateDebounceTimer = void 0), i(!1);
-        },
-        { once: !0 }
-      );
-    });
+  resetState() {
+    this.issueState.clear(), this.interaction.setTouched(!1), this.interaction.setDirty(!1);
   }
-  /**
-   * Немедленная валидация без debounce
-   * @private
-   * @param providedController - AbortController from debounced validate()
-   * @remarks
-   * Защищена от race conditions через AbortController:
-   * - Отменяет предыдущую валидацию при запуске новой (if no controller provided)
-   * - Передаёт AbortSignal в async валидаторы для отмены операций (например, fetch)
-   * - Проверяет signal.aborted в ключевых точках
-   */
-  async validateImmediate(e) {
-    const t = e ?? new AbortController();
-    e || this.currentAbortController?.abort(), this.currentAbortController = t;
-    const { signal: s } = t, i = [];
-    for (const n of this.validators) {
-      const l = n(this._value.value);
-      l && i.push(l);
-    }
-    if (s.aborted)
-      return !1;
-    if (i.length > 0) {
-      this._errors.value = i;
-      const n = i.some((l) => l.severity !== "warning");
-      if (this.statusMachine.setErrors(n), n)
-        return !1;
-    }
-    if (this.asyncValidators.length > 0) {
-      if (s.aborted)
-        return !1;
-      this.statusMachine.startValidation();
-      try {
-        const n = await Promise.all(
-          this.asyncValidators.map(async (d) => {
-            if (s.aborted)
-              throw new DOMException("Validation aborted", "AbortError");
-            try {
-              const u = await d(this._value.value, { signal: s });
-              if (s.aborted)
-                throw new DOMException("Validation aborted", "AbortError");
-              return u;
-            } catch (u) {
-              if (u instanceof DOMException && u.name === "AbortError")
-                throw u;
-              return F.handle(
-                u,
-                "FieldNode AsyncValidator",
-                A.CONVERT
-              );
-            }
-          })
-        );
-        if (s.aborted)
-          return !1;
-        const l = n.filter((d) => d !== null);
-        if (l.length > 0) {
-          this._errors.value = l;
-          const d = l.some((u) => u.severity !== "warning");
-          if (this.statusMachine.completeValidation(d), d)
-            return !1;
-        }
-      } catch (n) {
-        if (n instanceof DOMException && n.name === "AbortError")
-          return !1;
-        throw n;
-      }
-    }
-    return s.aborted ? !1 : ((this.validators.length > 0 || this.asyncValidators.length > 0) && (this._errors.value = [], this.statusMachine.completeValidation(!1)), !this._errors.value.some((n) => n.severity !== "warning"));
+  markAsTouched() {
+    this.interaction.setTouched(!0);
+  }
+  markAsUntouched() {
+    this.interaction.setTouched(!1);
   }
-  setErrors(e) {
-    this._errors.value = e;
-    const t = e.some((s) => s.severity !== "warning");
-    this.statusMachine.setErrors(t);
+  disable() {
+    this.availability.setDisabled(!0), this.issueState.clear();
   }
-  clearErrors() {
-    this._errors.value = [], this.statusMachine.setErrors(!1);
+  enable() {
+    this.locked = !1, this.availability.setDisabled(!1);
   }
-  // ============================================================================
-  // Protected hooks (Template Method pattern)
-  // ============================================================================
-  /**
-   * Hook: вызывается после markAsTouched()
-   *
-   * Для FieldNode: если updateOn === 'blur', запускаем валидацию
-   */
-  onMarkAsTouched() {
-    this.updateOn === "blur" && this.validate();
+  /** Каскад от контейнера: блокировку из схемы не снимает. @internal */
+  enableFromParent() {
+    this.locked || this.availability.setDisabled(!1);
   }
-  /**
-   * Hook: вызывается после disable()
-   *
-   * Для FieldNode: синхронизируем statusMachine и очищаем ошибки
-   */
-  onDisable() {
-    this.statusMachine.disable(), this._errors.value = [];
+  setIssues(e) {
+    this.issueState.set(e);
   }
-  /**
-   * Hook: вызывается после enable()
-   *
-   * Для FieldNode: синхронизируем statusMachine и запускаем валидацию
-   */
-  onEnable() {
-    this.statusMachine.enable(this._errors.value.length > 0), this.validate();
+  clearIssues() {
+    this.issueState.clear();
   }
-  /**
-   * Обновляет свойства компонента (например, опции для Select)
-   *
-   * @example
-   * ```typescript
-   * // Обновление опций для Select после загрузки справочников
-   * form.registrationAddress.city.updateComponentProps({
-   *   options: cities
-   * });
-   * ```
-   */
   updateComponentProps(e) {
-    this._componentProps.value = {
-      ...this._componentProps.value,
-      ...e
-    };
-  }
-  /**
-   * Динамически изменяет триггер валидации (updateOn)
-   * Полезно для адаптивной валидации - например, переключиться на instant feedback после первого submit
-   *
-   * @param updateOn - новый триггер валидации: 'change' | 'blur' | 'submit'
-   *
-   * @example
-   * ```typescript
-   * // Сценарий 1: Instant feedback после submit
-   * const form = createForm({
-   *   email: {
-   *     value: '',
-   *     component: Input,
-   *     updateOn: 'submit', // Изначально валидация только при submit
-   *     validators: [required, email],
-   *   },
-   * });
-   *
-   * await form.submit(async (values) => {
-   *   // После submit переключаем на instant feedback
-   *   form.email.setUpdateOn('change');
-   *   await api.save(values);
-   * });
-   *
-   * // Теперь валидация происходит при каждом изменении
-   *
-   * // Сценарий 2: Прогрессивное улучшение
-   * form.email.setUpdateOn('blur');  // Сначала только при blur
-   * // ... пользователь начинает вводить ...
-   * form.email.setUpdateOn('change'); // Переключаем на change для real-time feedback
-   * ```
-   */
-  setUpdateOn(e) {
-    this.updateOn = e;
+    this.componentState.update(e);
   }
-  getUpdateOn() {
-    return this.updateOn;
+  /** Раннер валидации: начало (`true`) и конец (`false`) async-правил поля. @internal */
+  setPending(e) {
+    this.pendingState.mark(e);
   }
-  // ============================================================================
-  // Методы-помощники для реактивности (Фаза 1)
-  // ============================================================================
-  /**
-   * Подписка на изменения значения поля
-   * Автоматически отслеживает изменения через @preact/signals effect
-   *
-   * @param callback - Функция, вызываемая при изменении значения.
-   *   Для async операций передается AbortSignal во втором параметре.
-   * @returns Функция отписки для cleanup
-   *
-   * @example
-   * ```typescript
-   * // Синхронный callback
-   * const unsubscribe = form.email.watch((value) => {
-   *   console.log('Email changed:', value);
-   * });
-   *
-   * // Асинхронный callback с поддержкой отмены
-   * const unsubscribe = form.email.watch(async (value, signal) => {
-   *   const result = await fetch('/api/validate', { signal });
-   *   // ...
-   * });
-   *
-   * // Cleanup
-   * useEffect(() => unsubscribe, []);
-   * ```
-   */
-  watch(e) {
-    const t = new AbortController(), s = E(() => {
-      const a = this.value.value;
-      e(a, t.signal);
-    }), i = V(w.Watch);
-    return this.disposers.add(i, () => {
-      t.abort(), s();
-    });
-  }
-  /**
-   * Вычисляемое значение из других полей
-   * Автоматически обновляет текущее поле при изменении источников
-   *
-   * @param sources - Массив ReadonlySignal для отслеживания
-   * @param computeFn - Функция вычисления нового значения
-   * @returns Функция отписки для cleanup
-   *
-   * @example
-   * ```typescript
-   * // Автоматический расчет первоначального взноса (20% от стоимости)
-   * const dispose = form.initialPayment.computeFrom(
-   *   [form.propertyValue.value],
-   *   (propertyValue) => {
-   *     return propertyValue ? propertyValue * 0.2 : null;
-   *   }
-   * );
-   *
-   * // Cleanup
-   * useEffect(() => dispose, []);
-   * ```
-   */
-  computeFrom(e, t) {
-    const s = E(() => {
-      const a = e.map((l) => l.value), n = t(...a);
-      this.setValue(n, { emitEvent: !1 });
-    }), i = V(w.ComputeFrom);
-    return this.disposers.add(i, s);
-  }
-  /**
-   * Очистить все ресурсы и таймеры
-   * Должен вызываться при unmount компонента
-   *
-   * @remarks
-   * Освобождает все ресурсы:
-   * - Отписывает все subscriptions через SubscriptionManager
-   * - Отменяет pending/running валидации через cancelPendingValidation()
-   *
-   * Использует try-finally для гарантированного cleanup даже при ошибках.
-   *
-   * @example
-   * ```typescript
-   * useEffect(() => {
-   *   return () => {
-   *     field.dispose();
-   *   };
-   * }, []);
-   * ```
-   */
-  dispose() {
-    try {
-      this.disposers.dispose();
-    } finally {
-      this.cancelPendingValidation();
-    }
+  /** У поля подписок нет. @internal */
+  dispose() {
   }
 }
-function L(r) {
-  const { getChildren: e, ownErrors: t, disabled: s } = r, i = c(() => t.value.length > 0 ? !1 : e().every((o) => o.disabled.value || o.valid.value)), a = c(() => !i.value), n = c(() => e().some((o) => o.pending.value)), l = c(() => e().some((o) => o.touched.value)), d = c(() => e().some((o) => o.dirty.value)), u = c(() => {
-    const o = [...t.value];
-    for (const p of e())
-      o.push(...p.errors.value);
-    return o;
-  }), v = c(() => s?.value ? "disabled" : n.value ? "pending" : a.value ? "invalid" : "valid");
+function Q(t) {
+  const { getChildren: e, ownIssues: s, ownPending: i } = t, n = () => t.disabled?.value ?? !1, a = d(() => s.value.some((l) => l.severity !== "warning")), r = d(
+    () => !n() && ((i?.value ?? !1) || e().some((l) => l.pending.value))
+  ), o = d(
+    () => !n() && !r.value && !a.value && e().every((l) => l.disabled.value || l.valid.value)
+  ), c = d(
+    () => !n() && !r.value && (a.value || e().some((l) => !l.disabled.value && l.invalid.value))
+  );
   return {
-    valid: i,
-    invalid: a,
-    pending: n,
-    touched: l,
-    dirty: d,
-    errors: u,
-    status: v
+    valid: o,
+    invalid: c,
+    pending: r,
+    touched: d(() => e().some((l) => l.touched.value)),
+    dirty: d(() => e().some((l) => l.dirty.value)),
+    issues: d(() => [
+      ...s.value,
+      ...e().flatMap((l) => l.issues.value)
+    ])
   };
 }
-function G(r) {
-  return typeof r == "object" && r !== null && "getProxy" in r && typeof r.getProxy == "function";
-}
-const j = "$";
-function ne(r, e) {
-  let t;
-  const s = () => {
-    if (!t) {
-      const i = {};
-      e.forEach((a, n) => {
-        i[n] = a && G(a) ? a.getProxy() : a;
-      }), t = i;
-    }
-    return t;
-  };
-  return new Proxy(r, {
-    get: (i, a) => {
-      if (a === j)
-        return s();
-      if (a in i)
-        return i[a];
-      if (typeof a == "string" && e.has(a)) {
-        const n = e.get(a);
-        return n && G(n) ? n.getProxy() : n;
-      }
-    },
-    set: (i, a, n) => typeof a == "string" && e.has(a) ? !1 : (i[a] = n, !0),
-    has: (i, a) => a === j || typeof a == "string" && e.has(a) ? !0 : a in i,
-    ownKeys: (i) => {
-      const a = Reflect.ownKeys(i), n = Array.from(e.keys());
-      return [.../* @__PURE__ */ new Set([...a, ...n])];
-    },
-    getOwnPropertyDescriptor: (i, a) => typeof a == "string" && e.has(a) ? { enumerable: !0, configurable: !0 } : Reflect.getOwnPropertyDescriptor(i, a)
-  });
-}
-class oe {
-  /**
-   * @param form - Форма для отправки
-   */
-  constructor(e) {
-    this.form = e;
-  }
-  /** Внутренний сигнал состояния отправки */
-  _submitting = g(!1);
-  /** Публичный read-only сигнал состояния отправки */
-  submitting = c(() => this._submitting.value);
-  /**
-   * Отправить форму
-   *
-   * Процесс:
-   * 1. Помечает все поля как touched (для отображения ошибок)
-   * 2. Валидирует форму
-   * 3. Если валидация успешна - вызывает onSubmit
-   * 4. Управляет состоянием submitting
-   *
-   * @param onSubmit - Callback для отправки данных
-   * @param options - Опции submit
-   * @returns Результат от onSubmit или `null` если валидация не пройдена
-   *
-   * @remarks
-   * Возвращаемый `null` неоднозначен: он сигналит и провал валидации, и легитимный `null`,
-   * который вернул `onSubmit` (или void-обработчик). Чтобы различать эти случаи, используйте
-   * {@link submitWithResult} — он отдаёт явный флаг `success`.
-   *
-   * @example
-   * ```typescript
-   * const result = await submitter.submit(async (values) => {
-   *   const response = await fetch('/api/form', {
-   *     method: 'POST',
-   *     body: JSON.stringify(values)
-   *   });
-   *   return response.json();
-   * });
-   *
-   * if (result === null) {
-   *   console.log('Форма не прошла валидацию');
-   * }
-   * ```
-   */
-  async submit(e, t) {
-    const { skipValidation: s = !1, skipTouch: i = !1 } = t || {};
-    if (i || this.form.markAsTouched(), !s && !await this.form.validate())
-      return null;
-    this._submitting.value = !0;
-    try {
-      return await e(this.form.getValue());
-    } finally {
-      this._submitting.value = !1;
-    }
-  }
-  /**
-   * Отправить форму с расширенным результатом
-   *
-   * В отличие от submit(), возвращает объект с информацией об успехе/ошибке
-   *
-   * @param onSubmit - Callback для отправки данных
-   * @param options - Опции submit
-   * @returns Объект SubmitResult с данными и статусом
-   *
-   * @example
-   * ```typescript
-   * const result = await submitter.submitWithResult(async (values) => {
-   *   return await api.saveForm(values);
-   * });
-   *
-   * if (result.success) {
-   *   console.log('Сохранено:', result.data);
-   * } else if (result.error) {
-   *   console.error('Ошибка:', result.error.message);
-   * } else {
-   *   console.log('Валидация не пройдена');
-   * }
-   * ```
-   */
-  async submitWithResult(e, t) {
-    const { skipValidation: s = !1, skipTouch: i = !1 } = t || {};
-    if (i || this.form.markAsTouched(), !s && !await this.form.validate())
-      return { success: !1, data: null };
-    this._submitting.value = !0;
-    try {
-      return { success: !0, data: await e(this.form.getValue()) };
-    } catch (a) {
-      return {
-        success: !1,
-        data: null,
-        error: a instanceof Error ? a : new Error(String(a))
-      };
-    } finally {
-      this._submitting.value = !1;
-    }
-  }
-  /**
-   * Проверить, идет ли отправка формы
-   */
-  isSubmitting() {
-    return this._submitting.value;
-  }
-}
-function le(r) {
-  const e = [];
-  for (const t of r.split(".")) {
-    const s = /^([^[\]]+)(?:\[(\d+)\])?$/.exec(t);
-    if (!s) return [];
-    e.push(s[2] !== void 0 ? { key: s[1], index: Number(s[2]) } : { key: s[1] });
-  }
-  return e;
-}
-class S extends M {
-  // ============================================================================
-  // Приватные поля
-  // ============================================================================
-  id = crypto.randomUUID();
-  /**
-   * Коллекция полей формы (упрощённый Map вместо FieldRegistry)
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  _fields = /* @__PURE__ */ new Map();
-  /**
-   * Менеджер подписок для централизованного cleanup
-   */
-  disposers = new I();
-  /**
-   * Ссылка на Proxy-инстанс
-   */
-  _proxyInstance;
-  /**
-   * Cleanup декларативной схемы поведения (createForm({ behavior })). Вызывается в dispose().
-   */
-  _behaviorCleanup;
-  /**
-   * Фабрика для создания узлов формы
-   */
-  nodeFactory = new ue();
-  // ============================================================================
-  // Приватные сигналы состояния (inline из StateManager)
-  // ============================================================================
-  /** Управление отправкой формы */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  formSubmitter;
-  /** Флаг disabled состояния */
-  _disabled = g(!1);
-  /** Form-level validation errors */
-  _formErrors = g([]);
-  /**
-   * M1: связь листовой ноды-ребёнка → её сигнал модели (тот, что помечает `markDerived`).
-   * Нужна bulk-сеттерам (`setValue`/`patchValue`), чтобы корректно определять derived-поля:
-   * `field.value` — computed-обёртка, отличная от записываемого сигнала модели. @internal
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  _fieldSignals = /* @__PURE__ */ new WeakMap();
-  // ============================================================================
-  // Публичные computed signals
-  // ============================================================================
-  value;
-  valid;
-  invalid;
-  touched;
-  dirty;
-  pending;
-  errors;
-  status;
-  submitting;
-  constructor(e) {
-    super(), this.formSubmitter = new oe(this);
-    const t = e.form, s = t != null && typeof t == "object" && ("valueSignal" in t || "value" in t), a = "form" in e && !s ? e.form : e;
-    for (const [l, d] of Object.entries(a)) {
-      const u = this.createNode(d);
-      this._fields.set(l, u);
-    }
-    this.value = c(() => {
-      const l = {};
-      return this._fields.forEach((d, u) => {
-        l[u] = d.value.value;
-      }), l;
-    });
-    const n = L({
-      getChildren: () => Array.from(this._fields.values()),
-      ownErrors: this._formErrors,
-      disabled: this._disabled
-    });
-    this.valid = n.valid, this.invalid = n.invalid, this.pending = n.pending, this.touched = n.touched, this.dirty = n.dirty, this.errors = n.errors, this.status = n.status, this.submitting = this.formSubmitter.submitting;
-  }
-  // ============================================================================
-  // Приватный метод для создания Proxy
-  // ============================================================================
-  /**
-   * Создать Proxy для типобезопасного доступа к полям
-   * @see buildFormProxy
-   */
-  buildProxy() {
-    return ne(this, this._fields);
-  }
-  // ============================================================================
-  // Реализация абстрактных методов FormNode
-  // ============================================================================
-  getValue() {
-    const e = {};
-    return this._fields.forEach((t, s) => {
-      e[s] = t.getValue();
-    }), e;
-  }
-  setValue(e, t) {
-    for (const [s, i] of Object.entries(e)) {
-      const a = this._fields.get(s);
-      if (a) {
-        const n = this._fieldSignals.get(a) ?? a.value;
-        if (B(n)) continue;
-        a.setValue(i, t);
-      }
-    }
-  }
-  patchValue(e) {
-    X(() => {
-      for (const [t, s] of Object.entries(e)) {
-        const i = this._fields.get(t);
-        if (i && s !== void 0) {
-          const a = this._fieldSignals.get(i) ?? i.value;
-          if (B(a)) continue;
-          i.setValue(s, { emitEvent: !1 });
-        }
-      }
-    });
-  }
-  /**
-   * Сбросить форму к указанным значениям (или к initialValues)
-   *
-   * @param value - опциональный объект со значениями для сброса
-   *
-   * @remarks
-   * Рекурсивно вызывает reset() для всех полей формы
-   *
-   * @example
-   * ```typescript
-   * // Сброс к initialValues
-   * form.reset();
-   *
-   * // Сброс к новым значениям
-   * form.reset({ email: 'new@mail.com', password: '' });
-   * ```
-   */
-  reset(e) {
-    this._formErrors.value = [], this._fields.forEach((t, s) => {
-      const i = e?.[s];
-      t.reset(i);
-    });
-  }
-  /**
-   * Сбросить форму к исходным значениям (initialValues)
-   */
-  resetToInitial() {
-    this._formErrors.value = [], this._fields.forEach((e) => {
-      "resetToInitial" in e && typeof e.resetToInitial == "function" ? e.resetToInitial() : e.reset();
-    });
-  }
-  async validate() {
-    return this.clearErrors(), await Promise.all(Array.from(this._fields.values()).map((t) => t.validate())), Array.from(this._fields.values()).every(
-      (t) => t.valid.value || t.disabled.value
-    );
-  }
-  /**
-   * Установить form-level validation errors
-   */
-  setErrors(e) {
-    this._formErrors.value = e;
-  }
-  /**
-   * Очистить все errors (form-level + field-level)
-   */
-  clearErrors() {
-    this._formErrors.value = [], this._fields.forEach((e) => e.clearErrors());
-  }
-  /**
-   * Получить поле по ключу
-   */
-  getField(e) {
-    return this._fields.get(e);
-  }
-  /**
-   * Получить Map всех полей формы (для совместимости)
-   */
-  get fields() {
-    return this._fields;
-  }
-  /**
-   * Получить Proxy-инстанс для прямого доступа к полям
-   *
-   * Proxy позволяет обращаться к полям формы напрямую через точечную нотацию:
-   * - form.email вместо form.fields.get('email')
-   * - form.address.city вместо form.fields.get('address').fields.get('city')
-   *
-   * Используется в:
-   * - BehaviorApplicator для доступа к полям в behavior functions
-   * - ValidationApplicator для доступа к форме в tree validators
-   *
-   * @returns Proxy-инстанс с типобезопасным доступом к полям или сама форма, если proxy не доступен
-   *
-   * @example
-   * ```typescript
-   * const form = new GroupNode({
-   *   email: { value: '', component: Input },
-   *   name: { value: '', component: Input },
-   * });
-   *
-   * const proxy = form.getProxy();
-   * console.log(proxy.email.value.value); // Прямой доступ к полю
-   * ```
-   */
-  getProxy() {
-    return this._proxyInstance || (this._proxyInstance = this.buildProxy()), this._proxyInstance;
-  }
-  /**
-   * Получить все поля формы как итератор
-   */
-  getAllFields() {
-    return this._fields.values();
-  }
-  // ============================================================================
-  // Protected hooks (Template Method pattern)
-  // ============================================================================
-  onMarkAsTouched() {
-    this._fields.forEach((e) => e.markAsTouched());
-  }
-  onMarkAsUntouched() {
-    this._fields.forEach((e) => e.markAsUntouched());
-  }
-  onMarkAsDirty() {
-    this._fields.forEach((e) => e.markAsDirty());
-  }
-  onMarkAsPristine() {
-    this._fields.forEach((e) => e.markAsPristine());
-  }
-  // ============================================================================
-  // Дополнительные методы (из FormStore)
-  // ============================================================================
-  /**
-   * Отправить форму
-   *
-   * @param onSubmit - Callback для отправки данных
-   * @param options - Опции submit (skipValidation, skipTouch)
-   * @returns Результат от onSubmit или `null` если валидация не пройдена
-   *
-   * @remarks
-   * `null` перегружен: он означает и «валидация не пройдена», и легитимный `null`-результат
-   * `onSubmit` (или void-обработчик). Если вызывающей стороне нужно различать эти случаи —
-   * используйте {@link submitWithResult}, который возвращает явный флаг `success`.
-   */
-  async submit(e, t) {
-    return this.formSubmitter.submit(e, t);
-  }
-  /**
-   * Отправить форму с расширенным результатом
-   *
-   * @param onSubmit - Callback для отправки данных
-   * @param options - Опции submit
-   * @returns Объект SubmitResult с данными, статусом и возможной ошибкой
-   */
-  async submitWithResult(e, t) {
-    return this.formSubmitter.submitWithResult(e, t);
-  }
-  /**
-   * Получить вложенное поле по пути
-   *
-   * Поддерживаемые форматы путей:
-   * - Simple: "email" - получить поле верхнего уровня
-   * - Nested: "address.city" - получить вложенное поле
-   * - Array index: "items[0]" - получить элемент массива по индексу
-   * - Combined: "items[0].name" - получить поле элемента массива
-   *
-   * @param path - Путь к полю
-   * @returns FormNode если найдено, undefined если путь не существует
-   *
-   * @example
-   * ```typescript
-   * const form = new GroupNode({
-   *   email: { value: '', component: Input },
-   *   address: {
-   *     city: { value: '', component: Input }
-   *   },
-   *   items: [{ name: { value: '', component: Input } }]
-   * });
-   *
-   * form.getFieldByPath('email');           // FieldNode
-   * form.getFieldByPath('address.city');    // FieldNode
-   * form.getFieldByPath('items[0]');        // GroupNode
-   * form.getFieldByPath('items[0].name');   // FieldNode
-   * form.getFieldByPath('invalid.path');    // undefined
-   * ```
-   */
-  getFieldByPath(e) {
-    if (e.startsWith(".") || e.endsWith("."))
-      return;
-    const t = le(e);
-    if (t.length === 0)
-      return;
-    let s = this;
-    for (const i of t) {
-      if (!(s instanceof S) || (s = s.getField(i.key), !s)) return;
-      if (i.index !== void 0)
-        if ("at" in s && "length" in s && typeof s.at == "function") {
-          const a = s.at(i.index);
-          if (!a) return;
-          s = a;
-        } else
-          return;
-    }
-    return s;
-  }
-  // ============================================================================
-  // Private методы для создания узлов
-  // ============================================================================
-  /**
-   * Создать узел на основе конфигурации
-   *
-   * ✅ РЕФАКТОРИНГ: Полное делегирование NodeFactory
-   *
-   * NodeFactory теперь обрабатывает:
-   * - Массивы [schema, ...items]
-   * - FieldConfig
-   * - GroupConfig
-   * - ArrayConfig
-   *
-   * @param config Конфигурация узла
-   * @returns Созданный узел формы
-   * @private
-   */
-  createNode(e) {
-    return this.nodeFactory.createNode(e);
-  }
-  // ============================================================================
-  // Методы-помощники для реактивности (Фаза 1)
-  // ============================================================================
-  /**
-   * Связывает два поля: при изменении source автоматически обновляется target
-   */
-  linkFields(e, t, s) {
-    const i = this._fields.get(e), a = this._fields.get(t);
-    if (!i || !a) {
-      const d = i ? t : e;
-      throw new Error(`GroupNode.linkFields: field "${String(d)}" not found`);
-    }
-    const n = E(() => {
-      const d = i.value.value, u = s ? s(d) : d;
-      a.setValue(u, { emitEvent: !1 });
-    }), l = V(w.LinkFields);
-    return this.disposers.add(l, 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, []);
-   * ```
-   */
-  /** Подписка на top-level поле — value типизирован как `T[K]`. */
-  watchField(e, t) {
-    const s = this.getFieldByPath(e);
-    if (!s)
-      throw new Error(`GroupNode.watchField: field "${e}" not found`);
-    const i = E(() => {
-      t(s.value.value);
-    }), a = V(w.WatchField);
-    return this.disposers.add(a, i);
-  }
-  /**
-   * Подписка на вложенное поле по строковому пути ("address.city").
-   * Путь нельзя выразить в типах узла → value честно `unknown`, потребитель сужает.
-   */
-  watchFieldByPath(e, t) {
-    const s = this.getFieldByPath(e);
-    if (!s)
-      throw new Error(`GroupNode.watchFieldByPath: field "${e}" not found`);
-    const i = E(() => {
-      t(s.value.value);
-    }), a = V(w.WatchField);
-    return this.disposers.add(a, i);
-  }
-  /**
-   * Hook: вызывается после disable()
-   */
-  onDisable() {
-    this._disabled.value = !0, this._fields.forEach((e) => e.disable());
-  }
-  /**
-   * Hook: вызывается после enable()
-   */
-  onEnable() {
-    this._disabled.value = !1, this._fields.forEach((e) => e.enable());
-  }
-  /**
-   * Прикрепить cleanup декларативной схемы поведения (вызывается createForm).
-   * @internal
-   */
-  attachBehaviorCleanup(e) {
-    this._behaviorCleanup = e;
-  }
-  /**
-   * Связать листовую ноду-ребёнка с её сигналом модели (M1). Вызывается `createForm` для каждого
-   * листового поля на его владеющей группе — используется bulk-сеттерами для derived-guard (F9).
-   * @internal
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  registerFieldSignal(e, t) {
-    this._fieldSignals.set(e, t);
-  }
-  /**
-   * Очистить все ресурсы узла
-   */
-  dispose() {
-    this._behaviorCleanup?.(), this._behaviorCleanup = void 0, this.disposers.dispose(), this._fields.forEach((e) => {
-      "dispose" in e && typeof e.dispose == "function" && e.dispose();
-    });
-  }
+const Me = [
+  "value",
+  "valid",
+  "invalid",
+  "pending",
+  "disabled",
+  "touched",
+  "dirty",
+  "issues",
+  "ownIssues",
+  "getValue",
+  "setValue",
+  "reset",
+  "markAsTouched",
+  "markAsUntouched",
+  "enable",
+  "disable",
+  "setIssues",
+  "clearIssues"
+], L = new Set(Me), N = "$";
+function Te(t) {
+  return Se(t) === "group" ? t.proxy : t;
 }
-class U extends M {
-  // ============================================================================
-  // Приватные поля
-  // ============================================================================
-  items;
-  itemSchema;
-  initialItems;
-  /**
-   * Менеджер подписок для централизованного cleanup
-   * Использует SubscriptionManager вместо массива для управления подписками
-   */
-  disposers = new I();
-  /** Array-level validation errors (e.g., "минимум 1 элемент") */
-  _arrayErrors = g([]);
-  // ============================================================================
-  // Приватные поля для сохранения схем
-  // ============================================================================
-  validationSchemaFn;
-  behaviorSchemaFn;
-  // ============================================================================
-  // Публичные computed signals
-  // ============================================================================
-  value;
-  valid;
-  invalid;
-  touched;
-  dirty;
-  pending;
-  errors;
-  status;
-  length;
-  // ============================================================================
-  // Конструктор
-  // ============================================================================
-  constructor(e, t = []) {
-    super(), this.itemSchema = e, this.initialItems = t, this.items = g([]);
-    for (const i of t)
-      this.push(i);
-    this.length = c(() => this.items.value.length), this.value = c(() => this.items.value.map((i) => i.value.value));
-    const s = L({
-      getChildren: () => this.items.value,
-      ownErrors: this._arrayErrors
-    });
-    this.valid = s.valid, this.invalid = s.invalid, this.pending = s.pending, this.touched = s.touched, this.dirty = s.dirty, this.errors = s.errors, this.status = s.status;
-  }
-  // ============================================================================
-  // CRUD операции
-  // ============================================================================
-  /**
-   * Добавить элемент в конец массива
-   * @param initialValue - Начальные значения для нового элемента
-   */
-  push(e) {
-    const t = this.createItem(e);
-    this.items.value = [...this.items.value, t];
-  }
-  /**
-   * Удалить элемент по индексу
-   * @param index - Индекс элемента для удаления
-   *
-   * @remarks
-   * Вызывает dispose() на удаляемом элементе для очистки подписок
-   */
-  removeAt(e) {
-    if (e < 0 || e >= this.items.value.length) {
-      F.handle(
-        new Error(
-          `ArrayNode.removeAt: index ${e} out of bounds (length: ${this.items.value.length})`
-        ),
-        "ArrayNode.removeAt",
-        A.LOG
-      );
-      return;
-    }
-    const t = this.items.value[e];
-    this.items.value = this.items.value.filter((s, i) => i !== e), t && "dispose" in t && typeof t.dispose == "function" && t.dispose();
-  }
-  /**
-   * Вставить элемент в массив
-   * @param index - Индекс для вставки
-   * @param initialValue - Начальные значения для нового элемента
-   */
-  insert(e, t) {
-    if (e < 0 || e > this.items.value.length) {
-      F.handle(
-        new Error(
-          `ArrayNode.insert: index ${e} out of bounds (length: ${this.items.value.length})`
-        ),
-        "ArrayNode.insert",
-        A.LOG
-      );
-      return;
-    }
-    const s = this.createItem(t), i = [...this.items.value];
-    i.splice(e, 0, s), this.items.value = i;
-  }
-  /**
-   * Переместить элемент массива с позиции `from` на позицию `to`
-   *
-   * @param from - Индекс перемещаемого элемента
-   * @param to - Целевой индекс
-   *
-   * @remarks
-   * Реордер не уничтожает элемент (dispose НЕ вызывается) — тот же инстанс под-формы
-   * переезжает на новую позицию, состояние/валидация сохраняются. Длина не меняется.
-   *
-   * @example
-   * ```typescript
-   * // Поднять элемент #2 на одну позицию вверх
-   * form.items.move(2, 1);
-   * ```
-   */
-  move(e, t) {
-    const s = this.items.value.length;
-    if (e < 0 || e >= s || t < 0 || t >= s) {
-      F.handle(
-        new Error(`ArrayNode.move: index out of bounds (from=${e}, to=${t}, length=${s})`),
-        "ArrayNode.move",
-        A.LOG
-      );
-      return;
+function De(t, e) {
+  let s;
+  const i = () => {
+    if (!s) {
+      const r = {};
+      e.forEach((o, c) => {
+        r[c] = Te(o);
+      }), s = Object.freeze(r);
     }
-    if (e === t) return;
-    const i = [...this.items.value], [a] = i.splice(e, 1);
-    i.splice(t, 0, a), this.items.value = i;
-  }
-  /**
-   * Поменять местами два элемента массива
-   *
-   * @param a - Индекс первого элемента
-   * @param b - Индекс второго элемента
-   *
-   * @remarks
-   * Как и {@link move}, не уничтожает элементы — меняет только их порядок.
-   *
-   * @example
-   * ```typescript
-   * form.items.swap(0, 2);
-   * ```
-   */
-  swap(e, t) {
-    const s = this.items.value.length;
-    if (e < 0 || e >= s || t < 0 || t >= s) {
-      F.handle(
-        new Error(`ArrayNode.swap: index out of bounds (a=${e}, b=${t}, length=${s})`),
-        "ArrayNode.swap",
-        A.LOG
-      );
-      return;
-    }
-    if (e === t) return;
-    const i = [...this.items.value];
-    [i[e], i[t]] = [i[t], i[e]], this.items.value = i;
-  }
-  /**
-   * Удалить все элементы массива
-   *
-   * @remarks
-   * Вызывает dispose() на всех элементах для очистки подписок
-   */
-  clear() {
-    const e = [...this.items.value];
-    this.items.value = [], e.forEach((t) => {
-      "dispose" in t && typeof t.dispose == "function" && t.dispose();
-    });
-  }
-  /**
-   * Получить элемент по индексу
-   * @param index - Индекс элемента
-   * @returns Типизированный GroupNode proxy или undefined если индекс вне границ
-   */
-  at(e) {
-    const t = this.items.value[e];
-    if (t)
-      return t.getProxy();
-  }
-  // ============================================================================
-  // Реализация абстрактных методов
-  // ============================================================================
-  getValue() {
-    return this.items.value.map((e) => e.getValue());
-  }
-  setValue(e, t) {
-    this.clear(), e.forEach((s) => this.push(s)), t?.emitEvent !== !1 && this.validate().catch((s) => {
-      F.handle(s, "ArrayNode.setValue", A.LOG);
-    });
-  }
-  patchValue(e) {
-    e.forEach((t, s) => {
-      this.items.value[s] && t !== void 0 && this.items.value[s].patchValue(t);
-    });
-  }
-  /**
-   * Сбросить массив к указанным значениям (или очистить)
-   *
-   * @param values - опциональный массив значений для сброса
-   *
-   * @remarks
-   * Очищает текущий массив и заполняет новыми элементами
-   *
-   * @example
-   * ```typescript
-   * // Очистить массив
-   * arrayNode.reset();
-   *
-   * // Сбросить к новым значениям
-   * arrayNode.reset([{ name: 'Item 1' }, { name: 'Item 2' }]);
-   * ```
-   */
-  reset(e) {
-    this._arrayErrors.value = [], this.clear(), e && e.forEach((t) => this.push(t));
-  }
-  /**
-   * Сбросить массив к исходным значениям (initialItems)
-   *
-   * @remarks
-   * Восстанавливает массив в состояние, которое было при создании ArrayNode.
-   * Более явный способ сброса к начальным значениям по сравнению с reset()
-   *
-   * Полезно когда:
-   * - Пользователь нажал "Cancel" - вернуть массив к исходным элементам
-   * - Массив был изменен через reset(newValues), но нужно вернуться к началу
-   * - Явное намерение показать "отмена всех изменений"
-   *
-   * @example
-   * ```typescript
-   * const arrayNode = new ArrayNode(
-   *   { name: { value: '', component: Input } },
-   *   [{ name: 'Initial 1' }, { name: 'Initial 2' }]
-   * );
-   *
-   * arrayNode.push({ name: 'New Item' });
-   * arrayNode.reset([{ name: 'Temp' }]);
-   * console.log(arrayNode.length.value); // 1
-   *
-   * arrayNode.resetToInitial();
-   * console.log(arrayNode.length.value); // 2
-   * console.log(arrayNode.at(0)?.name.value.value); // 'Initial 1'
-   * ```
-   */
-  resetToInitial() {
-    this._arrayErrors.value = [], this.clear(), this.initialItems.forEach((e) => this.push(e));
-  }
-  async validate() {
-    return (await Promise.all(this.items.value.map((t) => t.validate()))).every(Boolean) && this._arrayErrors.value.length === 0;
-  }
-  /**
-   * Установить array-level validation errors
-   *
-   * @param errors - Массив ошибок валидации уровня массива
-   *
-   * @example
-   * ```typescript
-   * arrayNode.setErrors([{
-   *   code: 'minItems',
-   *   message: 'Минимум 1 элемент обязателен',
-   * }]);
-   * ```
-   */
-  setErrors(e) {
-    this._arrayErrors.value = e;
-  }
-  /**
-   * Очистить все errors (array-level + item-level)
-   *
-   * @example
-   * ```typescript
-   * arrayNode.clearErrors();
-   * console.log(arrayNode.errors.value); // []
-   * ```
-   */
-  clearErrors() {
-    this._arrayErrors.value = [], this.items.value.forEach((e) => e.clearErrors());
-  }
-  // ============================================================================
-  // Protected hooks (Template Method pattern)
-  // ============================================================================
-  /**
-   * Hook: вызывается после markAsTouched()
-   *
-   * Для ArrayNode: рекурсивно помечаем все элементы массива как touched
-   */
-  onMarkAsTouched() {
-    this.items.value.forEach((e) => e.markAsTouched());
-  }
-  /**
-   * Hook: вызывается после markAsUntouched()
-   *
-   * Для ArrayNode: рекурсивно помечаем все элементы массива как untouched
-   */
-  onMarkAsUntouched() {
-    this.items.value.forEach((e) => e.markAsUntouched());
-  }
-  /**
-   * Hook: вызывается после markAsDirty()
-   *
-   * Для ArrayNode: рекурсивно помечаем все элементы массива как dirty
-   */
-  onMarkAsDirty() {
-    this.items.value.forEach((e) => e.markAsDirty());
-  }
-  /**
-   * Hook: вызывается после markAsPristine()
-   *
-   * Для ArrayNode: рекурсивно помечаем все элементы массива как pristine
-   */
-  onMarkAsPristine() {
-    this.items.value.forEach((e) => e.markAsPristine());
-  }
-  // ============================================================================
-  // Итерация
-  // ============================================================================
-  /**
-   * Итерировать по элементам массива
-   * @param callback - Функция, вызываемая для каждого элемента с типизированным GroupNode proxy
+    return s;
+  }, n = /* @__PURE__ */ new Map(), a = (r) => {
+    const o = Reflect.get(t, r, t);
+    if (typeof o != "function") return o;
+    let c = n.get(r);
+    return c || (c = o.bind(t), n.set(r, c)), c;
+  };
+  return new Proxy(t, {
+    get: (r, o) => o === ke ? t : o === N ? i() : L.has(o) ? a(o) : typeof o == "string" && e.has(o) ? i()[o] : a(o),
+    set: (r, o, c) => o === N || L.has(o) || typeof o == "string" && e.has(o) ? !1 : Reflect.set(t, o, c, t),
+    has: (r, o) => o === N || typeof o == "string" && e.has(o) || o in t,
+    ownKeys: () => [.../* @__PURE__ */ new Set([...Reflect.ownKeys(t), ...e.keys()])],
+    getOwnPropertyDescriptor: (r, o) => typeof o == "string" && e.has(o) ? { enumerable: !0, configurable: !0, value: i()[o] } : Reflect.getOwnPropertyDescriptor(t, o)
+  });
+}
+class _e {
+  [j] = "group";
+  value;
+  valid;
+  invalid;
+  pending;
+  disabled;
+  touched;
+  dirty;
+  issues;
+  ownIssues;
+  /** Сырые ноды детей по именам полей данных. */
+  children;
+  /** Замечания самой группы (ответ сервера на форму целиком). */
+  own = R();
+  availability = K();
+  /** Ожидание async-правила на ручке самой группы. */
+  ownPending = W();
+  /**
+   * Лист → его записываемый сигнал модели: по нему `setValue` узнаёт цели `compute` (их
+   * помечает `markDerived`), а не по computed-обёртке `value` ноды.
+   */
+  leafSignals = /* @__PURE__ */ new WeakMap();
+  behaviorCleanup;
+  face;
+  /**
+   * @param children - Готовые ноды детей по именам полей данных. Вид ребёнка задан нодой: по
+   *   именам и значениям группа ничего не угадывает.
    */
-  forEach(e) {
-    this.items.value.forEach((t, s) => {
-      const i = t.getProxy();
-      e(i, s);
+  constructor(e) {
+    this.children = new Map(e);
+    const s = [...this.children.values()];
+    this.value = d(() => {
+      const a = {};
+      return this.children.forEach((r, o) => {
+        a[o] = r.value.value;
+      }), a;
     });
-  }
-  /**
-   * Маппинг элементов массива
-   * @param callback - Функция преобразования с типизированным GroupNode proxy
-   * @returns Новый массив результатов
-   */
-  map(e) {
-    return this.items.value.map((t, s) => {
-      const i = t.getProxy();
-      return e(i, s);
+    const { disabled: i } = this.availability, n = Q({
+      getChildren: () => s,
+      ownIssues: this.own.list,
+      ownPending: d(() => !i.value && this.ownPending.active.value),
+      disabled: i
     });
+    this.valid = n.valid, this.invalid = n.invalid, this.pending = n.pending, this.touched = n.touched, this.dirty = n.dirty, this.issues = n.issues, this.ownIssues = this.own.list, this.disabled = this.availability.disabled;
   }
-  // ============================================================================
-  // Private методы
-  // ============================================================================
-  /**
-   * Создать новый элемент массива на основе схемы
-   * @param initialValue - Начальные значения
-   */
-  createItem(e) {
-    if (this.isGroupSchema(this.itemSchema)) {
-      const t = new S(this.itemSchema);
-      return e && t.patchValue(e), this.validationSchemaFn && "applyValidationSchema" in t && t.applyValidationSchema(this.validationSchemaFn), this.behaviorSchemaFn && "applyBehaviorSchema" in t && t.applyBehaviorSchema(this.behaviorSchemaFn), t;
-    }
-    throw new Error(
-      "ArrayNode поддерживает только GroupNode элементы. Для массива примитивов используйте обычное поле с типом массива."
-    );
+  /** Лицо группы: прокси с нодами полей. Строится один раз. */
+  get proxy() {
+    return this.face ??= De(this, this.children), this.face;
   }
-  /**
-   * Проверить, является ли схема групповой (объект полей)
-   * @param schema - Схема для проверки
-   */
-  isGroupSchema(e) {
-    return typeof e == "object" && e !== null && !("component" in e) && !Array.isArray(e);
+  getValue() {
+    const e = {};
+    return this.children.forEach((s, i) => {
+      e[i] = s.getValue();
+    }), e;
   }
-  // ============================================================================
-  // Validation Schema
-  // ============================================================================
-  /**
-   * Применить validation schema ко всем элементам массива
-   *
-   * Validation schema будет применена к:
-   * - Всем существующим элементам
-   * - Всем новым элементам, добавляемым через push/insert
-   *
-   * @param schemaFn - Функция валидации для элемента массива
-   *
-   * @example
-   * ```typescript
-   * import { propertyValidation } from './validation/property-validation';
-   *
-   * form.properties.applyValidationSchema(propertyValidation);
-   * ```
-   */
-  applyValidationSchema(e) {
-    this.validationSchemaFn = e, this.items.value.forEach((t) => {
-      "applyValidationSchema" in t && typeof t.applyValidationSchema == "function" && t.applyValidationSchema(e);
-    });
+  /** Записать значения полей; цели `compute` пропускаются — ими владеет поведение. */
+  setValue(e) {
+    if (!(e === null || typeof e != "object"))
+      for (const [s, i] of Object.entries(e)) {
+        const n = this.children.get(s);
+        if (!n) continue;
+        const a = this.leafSignals.get(n) ?? n.value;
+        T(a) || n.setValue(i);
+      }
   }
   /**
-   * Применить behavior schema ко всем элементам ArrayNode
-   *
-   * Автоматически применяется к новым элементам при push/insert.
-   *
-   * @param schemaFn - Behavior schema функция
-   *
-   * @example
-   * ```typescript
-   * import { addressBehavior } from './behaviors/address-behavior';
-   *
-   * form.addresses.applyBehaviorSchema(addressBehavior);
-   * ```
+   * Сбросить группу: замечания группы и всех полей, `touched`, `dirty` и значения. Без аргумента —
+   * к точке отсчёта модели, той же, к которой возвращает `model.reset()` (значения создания модели
+   * либо последнего `captureInitial()`), — и форма после сброса не изменена.
+   * Цели `compute` значения не получают, как и в `setValue`: ими владеет поведение.
    */
-  applyBehaviorSchema(e) {
-    this.behaviorSchemaFn = e, this.items.value.forEach((t) => {
-      "applyBehaviorSchema" in t && typeof t.applyBehaviorSchema == "function" && t.applyBehaviorSchema(e);
+  reset(e) {
+    this.own.clear(), this.children.forEach((s, i) => {
+      const n = this.leafSignals.get(s) ?? s.value, a = T(n) ? void 0 : e?.[i];
+      s.reset(a);
     });
   }
-  // ============================================================================
-  // Методы-помощники для реактивности (Фаза 1)
-  // ============================================================================
-  /**
-   * Подписка на изменения конкретного поля во всех элементах массива
-   * Срабатывает при изменении значения поля в любом элементе
-   *
-   * @param fieldKey - Ключ поля для отслеживания
-   * @param callback - Функция, вызываемая при изменении, получает массив всех значений и индекс измененного элемента
-   * @returns Функция отписки для cleanup
-   *
-   * @example
-   * ```typescript
-   * // Автоматический пересчет общей стоимости при изменении цен
-   * const dispose = form.existingLoans.watchItems(
-   *   'remainingAmount',
-   *   (amounts) => {
-   *     const totalDebt = amounts.reduce((sum, amount) => sum + (amount || 0), 0);
-   *     form.totalDebt.setValue(totalDebt);
-   *   }
-   * );
-   *
-   * // При изменении любого remainingAmount → пересчитается totalDebt
-   * form.existingLoans.at(0)?.remainingAmount.setValue(500000);
-   *
-   * // Cleanup
-   * useEffect(() => dispose, []);
-   * ```
-   */
-  watchItems(e, t) {
-    const s = E(() => {
-      const a = this.items.value.map((n) => {
-        if (n instanceof S)
-          return n.getFieldByPath(e)?.value.value;
-      });
-      t(a);
-    }), i = V(w.WatchItems);
-    return this.disposers.add(i, s);
+  /** Сброс всех полей группы к значениям создания, у целей `compute` тоже. @internal */
+  resetToCreation() {
+    this.own.clear(), this.children.forEach((e) => k(e).resetToCreation());
   }
-  /**
-   * Подписка на изменение длины массива
-   * Срабатывает при добавлении/удалении элементов
-   *
-   * @param callback - Функция, вызываемая при изменении длины, получает новую длину
-   * @returns Функция отписки для cleanup
-   *
-   * @example
-   * ```typescript
-   * // Обновление счетчика элементов в UI
-   * const dispose = form.properties.watchLength((length) => {
-   *   console.log(`Количество объектов недвижимости: ${length}`);
-   *   form.propertyCount.setValue(length);
-   * });
-   *
-   * form.properties.push({ title: 'Квартира', value: 5000000 });
-   * // Выведет: "Количество объектов недвижимости: 1"
-   *
-   * // Cleanup
-   * useEffect(() => dispose, []);
-   * ```
-   */
-  watchLength(e) {
-    const t = E(() => {
-      const i = this.length.value;
-      e(i);
-    }), s = V(w.WatchLength);
-    return this.disposers.add(s, t);
+  markAsTouched() {
+    this.children.forEach((e) => e.markAsTouched());
   }
-  /**
-   * Очистить все ресурсы узла
-   * Рекурсивно очищает все subscriptions и элементы массива
-   *
-   * @example
-   * ```typescript
-   * useEffect(() => {
-   *   return () => {
-   *     arrayNode.dispose();
-   *   };
-   * }, []);
-   * ```
-   */
-  dispose() {
-    this.disposers.dispose(), this.items.value.forEach((e) => {
-      "dispose" in e && typeof e.dispose == "function" && e.dispose();
-    });
+  markAsUntouched() {
+    this.children.forEach((e) => e.markAsUntouched());
   }
-  /**
-   * Hook: вызывается после disable()
-   *
-   * Для ArrayNode: рекурсивно отключаем все элементы массива
-   *
-   * @example
-   * ```typescript
-   * // Отключить весь массив полей
-   * form.items.disable();
-   *
-   * // Все элементы становятся disabled
-   * form.items.forEach(item => {
-   *   console.log(item.status.value); // 'disabled'
-   * });
-   * ```
-   */
-  onDisable() {
-    this.items.value.forEach((e) => {
-      e.disable();
-    });
+  disable() {
+    this.availability.setDisabled(!0), this.own.clear(), this.children.forEach((e) => e.disable());
   }
-  /**
-   * Hook: вызывается после enable()
-   *
-   * Для ArrayNode: рекурсивно включаем все элементы массива
-   *
-   * @example
-   * ```typescript
-   * // Включить весь массив полей
-   * form.items.enable();
-   *
-   * // Все элементы становятся enabled
-   * form.items.forEach(item => {
-   *   console.log(item.status.value); // 'valid' или 'invalid'
-   * });
-   * ```
-   */
-  onEnable() {
-    this.items.value.forEach((e) => {
-      e.enable();
-    });
+  /** Включить группу и детей; поля с блокировкой из схемы (`disabled: true`) остаются выключенными. */
+  enable() {
+    this.availability.setDisabled(!1), this.children.forEach((e) => k(e).enableFromParent());
   }
-}
-class ue {
-  /**
-   * Создает узел формы на основе конфигурации
-   *
-   * ✅ ОБНОВЛЕНО: Теперь поддерживает массивы напрямую
-   *
-   * Автоматически определяет тип узла:
-   * - FieldNode: имеет value и component
-   * - ArrayNode: массив [schema, ...items] или { schema, initialItems }
-   * - GroupNode: объект без value, component, schema
-   *
-   * @param config Конфигурация узла
-   * @returns Экземпляр FieldNode, GroupNode или ArrayNode
-   * @throws Error если конфиг не соответствует ни одному типу
-   *
-   * @example
-   * ```typescript
-   * const factory = new NodeFactory();
-   *
-   * // FieldNode
-   * const field = factory.createNode({
-   *   value: 'test@mail.com',
-   *   component: Input,
-   *   validators: [required, email]
-   * });
-   *
-   * // GroupNode
-   * const group = factory.createNode({
-   *   email: { value: '', component: Input },
-   *   password: { value: '', component: Input }
-   * });
-   *
-   * // ArrayNode (объект)
-   * const array = factory.createNode({
-   *   schema: { title: { value: '', component: Input } },
-   *   initialItems: [{ title: 'Item 1' }]
-   * });
-   *
-   * // ArrayNode (массив) - новый формат
-   * const array2 = factory.createNode([
-   *   { title: { value: '', component: Input } }, // schema
-   *   { title: 'Item 1' }, // initial item 1
-   *   { title: 'Item 2' }  // initial item 2
-   * ]);
-   * ```
-   */
-  createNode(e) {
-    if (Array.isArray(e) && e.length >= 1)
-      return this.createArrayNodeFromArray(e);
-    if (this.isFieldConfig(e))
-      return new ae(e);
-    if (this.isArrayConfig(e))
-      return new U(
-        e.schema,
-        e.initialItems
-      );
-    if (this.isGroupConfig(e))
-      return new S(e);
-    throw new Error(
-      `NodeFactory: Unknown node config. Expected FieldConfig, GroupConfig, or ArrayConfig, but got: ${JSON.stringify(
-        e
-      )}`
-    );
+  /** Каскад от контейнера — то же, что `enable()`: своей блокировки из схемы у группы нет. @internal */
+  enableFromParent() {
+    this.enable();
   }
-  /**
-   * Создать ArrayNode из массива [schema, ...initialItems]
-   *
-   * ✅ НОВОЕ: Извлечено из GroupNode для централизации логики
-   *
-   * Формат: [itemSchema, ...initialItems]
-   * - Первый элемент - схема элемента массива
-   * - Остальные элементы - начальные значения
-   *
-   * @param config Массив с схемой и начальными элементами
-   * @returns ArrayNode
-   *
-   * @example
-   * ```typescript
-   * const factory = new NodeFactory();
-   *
-   * // Массив с начальными элементами
-   * const array = factory.createArrayNodeFromArray([
-   *   { title: { value: '', component: Input } }, // schema
-   *   { title: 'Item 1' }, // initial value
-   *   { title: 'Item 2' }  // initial value
-   * ]);
-   * ```
-   * @private
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  createArrayNodeFromArray(e) {
-    const [t, ...s] = e, i = [];
-    this.isGroupConfig(t) && i.push(this.extractValues(t));
-    for (const a of s)
-      this.isGroupConfig(a) ? i.push(this.extractValues(a)) : i.push(a);
-    return new U(t, i);
+  setIssues(e) {
+    this.own.set(e);
   }
-  /**
-   * Извлечь значения из схемы (рекурсивно)
-   *
-   * ✅ НОВОЕ: Извлечено из GroupNode для централизации логики
-   *
-   * Преобразует схему формы в объект со значениями:
-   * - `{ name: { value: 'John', component: Input } } → { name: 'John' }`
-   * - Поддерживает вложенные группы
-   * - Поддерживает массивы
-   *
-   * @param schema Схема формы
-   * @returns Объект со значениями полей
-   *
-   * @example
-   * ```typescript
-   * const factory = new NodeFactory();
-   *
-   * const schema = {
-   *   name: { value: 'John', component: Input },
-   *   age: { value: 30, component: Input },
-   *   address: {
-   *     city: { value: 'Moscow', component: Input }
-   *   }
-   * };
-   *
-   * factory.extractValues(schema);
-   * // { name: 'John', age: 30, address: { city: 'Moscow' } }
-   * ```
-   */
-  extractValues(e) {
-    if (this.isFieldConfig(e))
-      return e.value;
-    if (Array.isArray(e))
-      return e.map((t) => this.extractValues(t));
-    if (this.isGroupConfig(e)) {
-      const t = {};
-      for (const [s, i] of Object.entries(e))
-        t[s] = this.extractValues(i);
-      return t;
-    }
-    return e;
+  clearIssues() {
+    this.own.clear(), this.children.forEach((e) => e.clearIssues());
   }
-  /**
-   * Проверяет, является ли конфиг конфигурацией поля (FieldConfig)
-   *
-   * FieldConfig имеет обязательные свойства:
-   * - value: начальное значение поля
-   * - component: React-компонент для отображения
-   *
-   * @param config Проверяемая конфигурация
-   * @returns true если config является FieldConfig
-   *
-   * @example
-   * ```typescript
-   * const factory = new NodeFactory();
-   *
-   * factory.isFieldConfig({ value: '', component: Input }); // true
-   * factory.isFieldConfig({ email: { value: '' } }); // false
-   * factory.isFieldConfig(null); // false
-   * ```
-   */
-  isFieldConfig(e) {
-    return e == null || typeof e != "object" ? !1 : "valueSignal" in e ? !0 : "value" in e ? "component" in e || "componentProps" in e || "validators" in e || "asyncValidators" in e || "updateOn" in e || "debounce" in e : !1;
+  /** Своё ожидание async-правила на ручке группы; ожидание детей агрегат добавит сам. @internal */
+  setPending(e) {
+    this.ownPending.mark(e);
   }
-  /**
-   * Проверяет, является ли конфиг конфигурацией массива (ArrayConfig)
-   *
-   * ArrayConfig имеет обязательное свойство:
-   * - schema: схема для элементов массива
-   *
-   * И НЕ имеет:
-   * - value (отличие от FieldConfig)
-   *
-   * @param config Проверяемая конфигурация
-   * @returns true если config является ArrayConfig
-   *
-   * @example
-   * ```typescript
-   * const factory = new NodeFactory();
-   *
-   * factory.isArrayConfig({ schema: {}, initialItems: [] }); // true
-   * factory.isArrayConfig({ value: '', component: Input }); // false
-   * factory.isArrayConfig({ email: { value: '' } }); // false
-   * ```
-   */
-  isArrayConfig(e) {
-    return e != null && typeof e == "object" && "schema" in e && !("value" in e);
+  /** Прикрепить cleanup поведения формы (`createForm({ behavior })`). @internal */
+  attachBehaviorCleanup(e) {
+    this.behaviorCleanup = e;
   }
-  /**
-   * Проверяет, является ли конфиг конфигурацией группы (GroupConfig)
-   *
-   * GroupConfig - это объект, который:
-   * - НЕ является FieldConfig (нет value/component)
-   * - НЕ является ArrayConfig (нет schema)
-   * - Содержит вложенные конфиги полей/групп/массивов
-   *
-   * @param config Проверяемая конфигурация
-   * @returns true если config является GroupConfig
-   *
-   * @example
-   * ```typescript
-   * const factory = new NodeFactory();
-   *
-   * factory.isGroupConfig({
-   *   email: { value: '', component: Input },
-   *   password: { value: '', component: Input }
-   * }); // true
-   *
-   * factory.isGroupConfig({ value: '', component: Input }); // false
-   * factory.isGroupConfig({ schema: {} }); // false
-   * factory.isGroupConfig(null); // false
-   * ```
-   */
-  isGroupConfig(e) {
-    return e != null && typeof e == "object" && !this.isFieldConfig(e) && !this.isArrayConfig(e);
+  /** Связать лист с его сигналом модели для `setValue`. @internal */
+  registerLeafSignal(e, s) {
+    this.leafSignals.set(e, s);
+  }
+  /** Снять поведение и подписки всех детей. @internal */
+  dispose() {
+    this.behaviorCleanup?.(), this.behaviorCleanup = void 0, this.children.forEach((e) => e.dispose());
   }
 }
-class de extends M {
-  /**
-   * @param control Реактивный массив модели (`model.<path>`).
-   * @param buildItem Строитель формы элемента по его под-модели (инъекция, чтобы избежать цикла
-   *   импорта с `create-form`). Обычно `(item) => createForm({ model: item, schema: itemSchema(item) })`.
-   */
-  constructor(e, t) {
-    super(), this.control = e, this.buildItem = t, this.initial = e.toArray(), this.disposeSync = E(() => {
-      const i = e.length, a = [], n = [];
-      for (let u = 0; u < i; u++) {
-        const v = e.at(u);
-        if (!v) continue;
-        let o = this.cache.get(v);
-        o || (o = t(v), this.cache.set(v, o)), a.push(v), n.push(o);
+const z = /* @__PURE__ */ new WeakMap();
+let je = 0;
+function Z(t) {
+  let e = z.get(t);
+  return e === void 0 && (e = je++, z.set(t, e)), e;
+}
+class Re {
+  /**
+   * @param control - Массив модели (`model.<путь>`).
+   * @param buildRow - Форма строки по её под-модели; инъекция снимает цикл импорта со сборкой.
+   */
+  constructor(e, s) {
+    this.control = e, this.initial = e.toArray(), this.stopSync = ge(() => {
+      const a = e.length, r = [], o = [];
+      for (let h = 0; h < a; h++) {
+        const u = e.at(h);
+        if (!u) continue;
+        let f = this.cache.get(u);
+        f || (f = A(() => {
+          const p = s(u);
+          return this.availability.disabled.peek() && p.disable(), p;
+        }), this.cache.set(u, f)), r.push(u), o.push(f);
       }
-      const l = new Set(a), d = [];
-      for (const u of this.mountedModels) {
-        if (l.has(u)) continue;
-        const v = this.cache.get(u);
-        this.cache.delete(u), v && d.push(v);
+      const c = new Set(r), l = [];
+      for (const h of this.mounted) {
+        if (c.has(h)) continue;
+        const u = this.cache.get(h);
+        this.cache.delete(h), u && l.push(u);
       }
-      this.mountedModels = a, this.itemNodes.value = n, d.forEach((u) => this.disposeItemNode(u));
-    }), this.length = c(() => this.itemNodes.value.length), this.value = c(() => this.itemNodes.value.map((i) => i.value.value));
-    const s = L({
-      getChildren: () => this.itemNodes.value,
-      ownErrors: this._arrayErrors
+      this.mounted = r, this.rows.value = o, A(() => l.forEach((h) => k(h).dispose()));
+    }), this.value = d(() => this.rows.value.map((a) => a.value.value));
+    const { disabled: i } = this.availability, n = Q({
+      getChildren: () => this.rows.value,
+      ownIssues: this.own.list,
+      ownPending: d(() => !i.value && this.ownPending.active.value),
+      disabled: i
     });
-    this.valid = s.valid, this.invalid = s.invalid, this.pending = s.pending, this.touched = s.touched, this.dirty = s.dirty, this.errors = s.errors, this.status = s.status;
-  }
-  itemNodes = g([]);
-  // Кэш per-item формы по идентичности фасада под-модели (фасады кэшируются в core).
-  cache = /* @__PURE__ */ new WeakMap();
-  // Фасады под-моделей, для которых сейчас смонтированы формы — «предыдущий» набор для
-  // реконсиляции в disposeSync. Выпавшие из массива элементы диспозятся и вытесняются из кэша.
-  mountedModels = [];
-  initial;
-  _arrayErrors = g([]);
-  disposeSync;
-  /**
-   * Сигнал per-item форм. Публичен в т.ч. чтобы `isArrayNode` распознавал узел как массив
-   * (duck-typing проверяет наличие `items`).
-   */
-  get items() {
-    return this.itemNodes;
+    this.valid = n.valid, this.invalid = n.invalid, this.pending = n.pending, this.touched = n.touched, this.dirty = d(() => this.reshaped.value || n.dirty.value), this.issues = n.issues, this.ownIssues = this.own.list, this.disabled = this.availability.disabled;
   }
+  [j] = "array";
   value;
   valid;
   invalid;
   pending;
+  disabled;
   touched;
   dirty;
-  errors;
-  status;
-  length;
-  // ── Доступ к элементам ─────────────────────────────────────────────────────
+  issues;
+  ownIssues;
+  rows = w([]);
+  /**
+   * Состав массива меняли методами ноды после создания или сброса. Как `dirty` поля: ставит запись
+   * через форму (`push`, `removeAt`, `move`, `setValue`…), а не запись в модель — загрузка данных
+   * массив изменённым не делает. Операция, которая состав не поменяла (`clear` пустого массива,
+   * `move(i, i)`), — тоже: поведение «очистить список при снятом флаге» после сброса формы её не
+   * испачкает. Снимает `reset`.
+   */
+  reshaped = w(!1);
+  /** Форма строки по фасаду под-модели элемента. */
+  cache = /* @__PURE__ */ new WeakMap();
+  /** Под-модели строк, для которых сейчас есть формы, — «прежний» набор для сверки. */
+  mounted = [];
+  initial;
+  own = R();
+  availability = K();
+  /** Ожидание async-правила на ручке самого массива. */
+  ownPending = W();
+  stopSync;
+  get length() {
+    return this.rows.value.length;
+  }
   at(e) {
-    return this.itemNodes.value[e];
+    return this.rows.value[e];
   }
   map(e) {
-    return this.itemNodes.value.map((t, s) => e(t, s));
+    return this.rows.value.map(e);
   }
   forEach(e) {
-    this.itemNodes.value.forEach((t, s) => e(t, s));
+    this.rows.value.forEach(e);
+  }
+  keyAt(e) {
+    const s = e < this.rows.value.length ? this.mounted[e] : void 0;
+    if (s === void 0)
+      throw new RangeError(`[@reformer/core] FormArray.keyAt: no row at index ${e}`);
+    return String(Z(s));
   }
-  // ── Мутации (делегируют массиву модели; effect пересоберёт itemNodes) ──────
   push(e) {
-    this.control.push(e ?? {});
+    this.reshape(() => this.control.push(e));
   }
-  insert(e, t) {
-    this.control.insertAt(e, t ?? {});
+  insert(e, s) {
+    this.reshape(() => this.control.insertAt(this.modelIndex(e), s));
   }
   removeAt(e) {
-    this.control.removeAt(e);
+    this.reshape(() => this.control.removeAt(this.modelIndex(e)));
   }
-  /**
-   * Переместить элемент модель-массива. Делегирует мутацию массиву модели; внутренний `effect`
-   * пересоберёт `itemNodes` в новом порядке (per-item формы сохраняются по кешу идентичности).
-   */
-  move(e, t) {
-    this.control.move(e, t);
+  move(e, s) {
+    this.reshape(() => this.control.move(this.modelIndex(e), this.modelIndex(s)));
   }
-  /** Поменять местами два элемента модель-массива (см. {@link move}). */
-  swap(e, t) {
-    this.control.swap(e, t);
+  swap(e, s) {
+    this.reshape(() => this.control.swap(this.modelIndex(e), this.modelIndex(s)));
   }
   clear() {
-    this.control.clear();
+    this.reshape(() => this.control.clear());
   }
-  // ── Абстрактные методы FormNode ────────────────────────────────────────────
   getValue() {
     return this.control.toArray();
   }
   setValue(e) {
-    this.control.clear(), (e ?? []).forEach((t) => this.control.push(t));
-  }
-  patchValue(e) {
-    this.setValue(e);
+    this.reshape(() => {
+      this.control.clear(), (e ?? []).forEach((s) => this.control.push(s));
+    });
   }
+  /**
+   * Сбросить массив: строки, замечания и `dirty`. Без аргумента — к точке отсчёта модели, той же, к
+   * которой возвращает `model.reset()`: элементам создания модели либо последнего
+   * `captureInitial()`.
+   */
   reset(e) {
-    this._arrayErrors.value = [], this.setValue(e ?? this.initial);
+    this.own.clear(), this.setValue(e ?? this.referenceItems()), this.reshaped.value = !1;
   }
-  resetToInitial() {
-    this.reset(this.initial);
+  /** Строки пересобираются из значений создания — их поведение считает заново. @internal */
+  resetToCreation() {
+    this.own.clear(), this.setValue(this.initial), this.reshaped.value = !1;
   }
-  async validate() {
-    return (await Promise.all(
-      this.itemNodes.value.map(
-        (t) => t.validate()
-      )
-    )).every(Boolean) && this._arrayErrors.value.length === 0;
+  /** Точка отсчёта модели за массивом; без модели — элементы создания. */
+  referenceItems() {
+    const e = H(this.control);
+    return e === void 0 ? this.initial : e.value;
   }
-  setErrors(e) {
-    this._arrayErrors.value = e;
+  markAsTouched() {
+    this.rows.value.forEach((e) => e.markAsTouched());
   }
-  clearErrors() {
-    this._arrayErrors.value = [], this.itemNodes.value.forEach(
-      (e) => e.clearErrors?.()
-    );
+  markAsUntouched() {
+    this.rows.value.forEach((e) => e.markAsUntouched());
   }
-  // ── Hooks (forward к элементам) ────────────────────────────────────────────
-  // Агрегатное состояние (touched/dirty/status) выводится из детей (createAggregateSignals), поэтому
-  // базовые сигналы бесполезны для чтения — состояние меняется ТОЛЬКО через per-item формы. Форвардим
-  // ВСЕ hook'и (как ArrayNode), иначе markAsUntouched/Pristine/Dirty/disable/enable молча no-op.
-  onMarkAsTouched() {
-    this.itemNodes.value.forEach(
-      (e) => e.markAsTouched?.()
-    );
+  disable() {
+    this.availability.setDisabled(!0), this.own.clear(), this.rows.value.forEach((e) => e.disable());
   }
-  onMarkAsUntouched() {
-    this.itemNodes.value.forEach(
-      (e) => e.markAsUntouched?.()
-    );
+  /** Включить массив и строки; поля с блокировкой из схемы (`disabled: true`) остаются выключенными. */
+  enable() {
+    this.availability.setDisabled(!1), this.rows.value.forEach((e) => k(e).enableFromParent());
   }
-  onMarkAsDirty() {
-    this.itemNodes.value.forEach(
-      (e) => e.markAsDirty?.()
-    );
+  /** Каскад от контейнера — то же, что `enable()`: своей блокировки из схемы у массива нет. @internal */
+  enableFromParent() {
+    this.enable();
   }
-  onMarkAsPristine() {
-    this.itemNodes.value.forEach(
-      (e) => e.markAsPristine?.()
-    );
+  setIssues(e) {
+    this.own.set(e);
   }
-  onDisable() {
-    this.itemNodes.value.forEach((e) => e.disable?.());
+  clearIssues() {
+    this.own.clear(), this.rows.value.forEach((e) => e.clearIssues());
   }
-  onEnable() {
-    this.itemNodes.value.forEach((e) => e.enable?.());
+  /** Своё ожидание async-правила на ручке массива; ожидание строк агрегат добавит сам. @internal */
+  setPending(e) {
+    this.ownPending.mark(e);
   }
-  /** Диспозит форму элемента (эффекты/поведения/вложенные подписки); терпима к не-GroupNode. */
-  disposeItemNode(e) {
-    e.dispose?.();
+  /** Выполнить мутацию массива модели и отметить `dirty`, если состав строк изменился. */
+  reshape(e) {
+    const s = this.composition();
+    e();
+    const i = this.composition();
+    (i.length !== s.length || i.some((n, a) => n !== s[a])) && (this.reshaped.value = !0);
   }
   /**
-   * Очистка подписки синхронизации И детерминированный teardown всех форм элементов.
-   * Без пробрасывания dispose в itemNodes эффекты/поведения каждой формы элемента (в т.ч. disposeSync
-   * вложенных ModelArrayNode) остались бы жить после teardown формы — утечка подписок.
+   * Индекс модели для индекса строки формы. Без `null`-элементов они совпадают; с ними строка `i` —
+   * `i`-й непустой элемент, а индекс за последней строкой — конец массива модели. Читает модель, а не
+   * `mounted`: внутри `batch` синхронизация ещё не прошла.
    */
+  modelIndex(e) {
+    return A(() => {
+      const s = [];
+      for (let i = 0; i < this.control.length; i++)
+        this.control.at(i) && s.push(i);
+      return s.length === this.control.length ? e : e >= 0 && e < s.length ? s[e] : e === s.length ? this.control.length : e;
+    });
+  }
+  /** Под-модели строк по порядку — без подписки: мутацию могут вызвать из effect'а поведения. */
+  composition() {
+    return A(
+      () => Array.from({ length: this.control.length }, (e, s) => this.control.at(s))
+    );
+  }
+  /** Остановить синхронизацию и диспозить формы всех строк. @internal */
   dispose() {
-    this.disposeSync(), this.itemNodes.value.forEach((e) => this.disposeItemNode(e)), this.mountedModels = [];
+    this.stopSync(), this.rows.peek().forEach((e) => k(e).dispose()), this.mounted = [];
   }
 }
-const J = (r) => r !== null && typeof r == "object" && !Array.isArray(r) && !(r instanceof Date) && !(typeof Blob < "u" && r instanceof Blob) && !(typeof File < "u" && r instanceof File);
-function D(r, e, t) {
-  if (r == null || typeof r != "object" || r instanceof $) return;
-  if (Array.isArray(r)) {
-    for (const a of r) D(a, e, t);
-    return;
-  }
-  const s = r, i = s.array;
-  if (i && typeof i.__path == "string" && typeof s.item == "function") {
-    t.set(i.__path, s.item);
-    return;
-  }
-  s.value instanceof $ ? e.set(s.value, {
-    component: s.component,
-    componentProps: s.componentProps,
-    validators: s.validators,
-    asyncValidators: s.asyncValidators,
-    updateOn: s.updateOn,
-    disabled: s.disabled,
-    debounce: s.debounce
-  }) : process.env.NODE_ENV !== "production" && s.component !== void 0 && ("valueSignal" in s || s.value != null) && console.warn(
-    "[reformer] createForm({ schema }): узел с `component` не распознан как поле — `value` не является сигналом модели. Ожидается `value: model.$.<path>`; проверьте, что не передан `value: model.<path>` (value-прокси) или `valueSignal:`."
-  );
-  for (const [a, n] of Object.entries(s))
-    a !== "value" && D(n, e, t);
+const q = /* @__PURE__ */ new WeakMap();
+function ee(t, e) {
+  let s = q.get(e);
+  return s || (s = /* @__PURE__ */ new Map(), q.set(e, s)), s.has(t) || s.set(t, t(e)), s.get(t);
 }
-function Y(r, e, t, s) {
-  const i = {};
-  for (const [a, n] of Object.entries(e)) {
-    const l = t === "" ? a : `${t}.${a}`;
-    if (Array.isArray(n))
-      continue;
-    if (J(n)) {
-      i[a] = Y(r, n, l, s);
-      continue;
+const b = "[@reformer/core] compileSchema", Ke = /* @__PURE__ */ new Set([
+  "model",
+  "item",
+  "part",
+  "children",
+  "component",
+  "componentProps",
+  "selector",
+  "disabled",
+  "initialValue"
+]), x = {
+  value: "привязка поля — `model: model.$.<поле>`",
+  array: "привязка массива под-форм — `model: model.$.<массив>`"
+}, We = Object.freeze({}), te = /* @__PURE__ */ new WeakSet();
+function lt(t) {
+  return t !== null && typeof t == "object" && te.has(t);
+}
+function se(t) {
+  return de(t)?.path;
+}
+function ie(t, e, s) {
+  const i = se(t);
+  if (i === void 0) return s;
+  const n = e.basePath;
+  return n === void 0 || n === "" ? i : i.startsWith(`${n}.`) ? i.slice(n.length + 1) : i;
+}
+function Be(t) {
+  return typeof t == "string" || typeof t == "number" || J(t);
+}
+function Ue(t) {
+  return t == null || typeof t == "boolean";
+}
+function g(t) {
+  process.env.NODE_ENV !== "production" && typeof console < "u" && console.warn(t);
+}
+function F(t, e, s) {
+  const i = typeof t.selector == "string" && t.selector !== "" ? t.selector : void 0;
+  if (i !== void 0) {
+    const n = s.selectorPaths.get(i);
+    if (n !== void 0)
+      throw new Error(
+        `${b}: в области «${s.scope}» селектор «${i}» повторяется — узлы ${n} и ${e}. По \`selector\` узел адресуют поведение и шаги, поэтому в области он уникален. Дайте узлам разные селекторы; в строках массива и подформах селекторы живут в своих областях и с корнем не пересекаются.`
+      );
+    s.selectorPaths.set(i, e);
+  }
+  return {
+    id: i ?? e,
+    path: e,
+    selector: i,
+    scope: s.scope,
+    component: t.component,
+    props: t.componentProps ?? We,
+    source: t
+  };
+}
+function I(t, e) {
+  const s = e.nodes.get(t.id);
+  if (s !== void 0)
+    throw new Error(
+      `${b}: в области «${e.scope}» идентификатор «${t.id}» занят — узлы ${s.path} и ${t.path}. Селектор не может совпадать с позиционным путём узла (\`#/…\`): дайте узлу другой селектор.`
+    );
+  return te.add(t), e.nodes.set(t.id, t), t;
+}
+function oe(t, e, s) {
+  const i = t.get(e);
+  i !== void 0 && g(
+    `${b}: ручка «${s.handle.__path}» привязана к двум полям — узлы ${i.path} и ${s.path}. Нода формы у ручки одна и возьмёт конфиг последнего узла (component, componentProps, disabled). Значение второй раз показывают текстом — сигналом ручки в \`children\`.`
+  ), t.set(e, s);
+}
+function V(t, e, s) {
+  const i = F(t, e, s), n = [], a = t.children;
+  if (Array.isArray(a)) {
+    let o = null;
+    for (let c = 0; c < a.length; c++) {
+      const l = a[c], h = `${e}/${c}`;
+      if (!Ue(l)) {
+        if (Be(l)) {
+          o === null && (o = { id: h, parts: [] }, n.push({ kind: "text", id: o.id, parts: o.parts })), o.parts.push(l);
+          continue;
+        }
+        if (o = null, typeof l != "object" || X(l) || ve(l)) {
+          g(
+            `${b}: ребёнок ${h} — не узел и не текст (группа модели, под-модель либо значение другого типа); он пропущен. Текст — строка, число или сигнал; группу подключают узлом \`{ model: model.$.<группа>, part }\`.`
+          );
+          continue;
+        }
+        n.push(ne(l, h, s));
+      }
     }
-    const d = r.signalAt(l);
-    if (!d) throw new Error(`createForm({ model }): не найден сигнал для пути "${l}"`);
-    const u = s.get(d) ?? {}, { validators: v, asyncValidators: o, ...p } = u;
-    i[a] = { ...p, valueSignal: d };
   }
-  return i;
+  const r = Object.keys(t).every((o) => o === "selector" || o === "componentProps");
+  return i.component === void 0 && a === void 0 && r && g(
+    `${b}: узел ${i.id} — без \`component\` и без \`children\`: он ничего не рисует, и \`componentProps\` ему некому отдать. Пустую секцию объявляют с \`children: []\`, узел с разметкой — с \`component\`.`
+  ), I({ ...i, kind: "container", children: n }, s);
 }
-function z(r, e, t) {
-  for (const [s, i] of Object.entries(r)) {
-    const a = e === "" ? s : `${e}.${s}`;
-    Array.isArray(i) || (J(i) ? z(i, a, t) : t.push(a));
+function ne(t, e, s) {
+  if (s.ancestors.has(t))
+    throw new Error(`${b}: узел ${e} содержит сам себя — дерево схемы зациклено.`);
+  s.ancestors.add(t);
+  try {
+    return Le(t, e, s);
+  } finally {
+    s.ancestors.delete(t);
   }
 }
-function Q(r) {
-  const { model: e, schema: t, behavior: s } = r, i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map();
-  t !== void 0 && D(t, i, a);
-  const n = Y(e, e.get(), "", i), l = new S(n), d = e.get();
-  for (const [o, p] of Object.entries(d)) {
-    if (!Array.isArray(p)) continue;
-    const h = a.get(o);
-    if (!h) continue;
-    const f = e[o], m = (y) => Q({ model: y, schema: h(y) }), b = new de(f, m);
-    l.fields.set(o, b);
-  }
-  const u = l.getProxy(), v = [];
-  z(e.get(), "", v);
-  for (const o of v) {
-    const p = e.signalAt(o), h = l.getFieldByPath(o);
-    if (p && h) {
-      Z(p, h);
-      const f = o.lastIndexOf("."), m = f === -1 ? l : l.getFieldByPath(o.slice(0, f));
-      m instanceof S && m.registerFieldSignal(h, p);
-    }
+function Le(t, e, s) {
+  if (process.env.NODE_ENV !== "production")
+    for (const i of Object.keys(t)) Ke.has(i) || s.unknownKeys.add(i);
+  if (typeof t.item == "function") {
+    const i = he(t.model);
+    return i ? ze(t, i, e, s) : (g(
+      `${b}: у узла с \`item\` привязка — не массив модели (узел ${e}); он стал контейнером без строк. Ожидается \`model: model.$.<массив>\`; начальное значение поля должно быть массивом, а не \`null\`.`
+    ), V(t, e, s));
+  }
+  if (typeof t.part == "function") {
+    const i = fe(t.model);
+    return i ? qe(t, i, e, s) : (g(
+      `${b}: у узла с \`part\` привязка — не группа модели (узел ${e}); он стал контейнером. Ожидается \`model: model.$.<группа>\`.`
+    ), V(t, e, s));
+  }
+  if (J(t.model)) {
+    const i = t.model, n = I(
+      { ...F(t, e, s), kind: "field", handle: i, disabled: t.disabled === !0 },
+      s
+    );
+    return oe(s.fields, i, n), n;
   }
-  return s && l.attachBehaviorCleanup(s.__run(e, u)), u;
+  return t.model != null && g(
+    `${b}: привязка узла не распознана (узел ${e}) — он не стал полем. Ожидается \`model: model.$.<path>\` (лист или массив); проверьте, что не передан \`model: model.<path>\` (value-фасад) или группа без \`part\`.`
+  ), V(t, e, s);
 }
-const he = (r) => r != null && typeof r == "object" && "model" in r && typeof r.model?.signalAt == "function";
-function Oe(r) {
-  return he(r) ? Q(r) : new S(r).getProxy();
+function ze(t, e, s, i) {
+  const n = t.item, a = ie(e, i, s), r = `${i.scope}/${a}`, o = /* @__PURE__ */ new WeakMap(), c = /* @__PURE__ */ new Set(), l = I(
+    {
+      ...F(t, s, i),
+      kind: "array",
+      handle: e,
+      control: _(e),
+      initialValue: t.initialValue,
+      row(h) {
+        let u = o.get(h);
+        if (!u) {
+          const f = /* @__PURE__ */ new Set();
+          u = B(
+            ee(n, h),
+            h,
+            `${r}[${Z(h)}]`,
+            f
+          );
+          const p = [...f].filter((y) => !c.has(y));
+          if (p.length > 0) {
+            for (const y of p) c.add(y);
+            re(new Set(p));
+          }
+          o.set(h, u);
+        }
+        return u;
+      }
+    },
+    i
+  );
+  return i.arrays.set(e, l), l;
 }
-function x(r) {
-  return r == null ? !1 : typeof r == "object" && "value" in r && "setValue" in r && "getValue" in r && "validate" in r;
+function qe(t, e, s, i) {
+  const n = F(t, s, i), a = _(e), r = `${i.scope}/${ie(e, i, s)}`, o = B(
+    ee(t.part, a),
+    a,
+    r,
+    i.unknownKeys,
+    i.ancestors
+  );
+  for (const [c, l] of o.fields) oe(i.fields, c, l);
+  for (const [c, l] of o.arrays) i.arrays.set(c, l);
+  return I({ ...n, kind: "part", handle: e, model: a, content: o }, i);
 }
-function ce(r) {
-  return r == null ? !1 : x(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 B(t, e, s, i, n = /* @__PURE__ */ new Set()) {
+  if (t === null || typeof t != "object")
+    throw new Error(`${b}: корень области «${s}» — не узел схемы: ${String(t)}.`);
+  const a = e !== void 0 ? e.$ : void 0, r = {
+    scope: s,
+    basePath: se(a),
+    nodes: /* @__PURE__ */ new Map(),
+    fields: /* @__PURE__ */ new Map(),
+    arrays: /* @__PURE__ */ new Map(),
+    selectorPaths: /* @__PURE__ */ new Map(),
+    ancestors: n,
+    unknownKeys: i
+  }, o = ne(t, "#", r);
+  return {
+    scope: s,
+    model: e,
+    root: o,
+    nodes: r.nodes,
+    fields: r.fields,
+    arrays: r.arrays
+  };
 }
-function fe(r) {
-  return r == null ? !1 : x(r) && "getFieldByPath" in r && "fields" in r && // GroupNode НЕ имеет items/push/removeAt (это ArrayNode/ModelArrayNode)
-  !("items" in r) && !("push" in r) && !("removeAt" in r);
+function xe(t, e, s) {
+  const i = /* @__PURE__ */ new Set(), n = B(t, e, s, i);
+  return i.size > 0 && re(i), n;
 }
-function ve(r) {
-  return r == null ? !1 : x(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 re(t) {
+  const e = [...t], s = e.filter((i) => i in x).map((i) => `\`${i}\`: ${x[i]}`);
+  g(
+    `${b}: у узлов схемы есть ключи, которые сборка не читает: ${e.map((i) => `\`${i}\``).join(", ")}. Узел описывают \`model\`, \`item\`, \`part\`, \`children\`, \`component\`, \`componentProps\`, \`selector\`, \`disabled\` и \`initialValue\`; вложенные узлы читаются только из \`children\`.` + (s.length > 0 ? ` ${s.join("; ")}.` : "")
+  );
 }
-function Ne(r) {
-  return ce(r) ? "FieldNode" : fe(r) ? "GroupNode" : ve(r) ? "ArrayNode" : x(r) ? "FormNode" : "Unknown";
+function ae(t, e, s) {
+  return xe(t, e, s?.scope ?? "#");
 }
-var N = { exports: {} }, P = {};
-var W;
-function pe() {
-  if (W) return P;
-  W = 1;
-  var r = K;
-  function e(o, p) {
-    return o === p && (o !== 0 || 1 / o === 1 / p) || o !== o && p !== p;
-  }
-  var t = typeof Object.is == "function" ? Object.is : e, s = r.useState, i = r.useEffect, a = r.useLayoutEffect, n = r.useDebugValue;
-  function l(o, p) {
-    var h = p(), f = s({ inst: { value: h, getSnapshot: p } }), m = f[0].inst, b = f[1];
-    return a(
-      function() {
-        m.value = h, m.getSnapshot = p, d(m) && b({ inst: m });
-      },
-      [o, h, p]
-    ), i(
-      function() {
-        return d(m) && b({ inst: m }), o(function() {
-          d(m) && b({ inst: m });
-        });
-      },
-      [o]
-    ), n(h), h;
-  }
-  function d(o) {
-    var p = o.getSnapshot;
-    o = o.value;
-    try {
-      var h = p();
-      return !t(o, h);
-    } catch {
-      return !0;
+const Ge = { fields: /* @__PURE__ */ new Map(), arrays: /* @__PURE__ */ new Map() }, Ye = (t) => (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ((e) => U({ model: e, compiled: t.row(e) }))
+);
+function le(t, e) {
+  const s = /* @__PURE__ */ new Map(), i = [], n = (r, o) => {
+    const c = e.fields.get(o), l = c ? {
+      component: c.component,
+      componentProps: c.source.componentProps,
+      disabled: c.disabled
+    } : {}, h = new Ce({ ...l, valueSignal: o });
+    s.set(r, h), O(o, h), i.push([h, o]);
+  };
+  for (const r of Object.keys(t)) {
+    const o = t[r];
+    if (me(o)) {
+      const c = e.arrays.get(o);
+      if (c) {
+        const l = _(o), h = new Re(l, Ye(c));
+        s.set(r, h), O(o, h);
+      } else e.fields.has(o) && n(r, o);
+      continue;
     }
+    if (X(o)) {
+      const c = le(o, e);
+      s.set(r, c), O(o, c.proxy);
+      continue;
+    }
+    n(r, o);
   }
-  function u(o, p) {
-    return p();
-  }
-  var v = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? u : l;
-  return P.useSyncExternalStore = r.useSyncExternalStore !== void 0 ? r.useSyncExternalStore : v, P;
+  const a = new _e(s);
+  for (const [r, o] of i) a.registerLeafSignal(r, o);
+  return a;
 }
-var T = {};
-var q;
-function me() {
-  return q || (q = 1, process.env.NODE_ENV !== "production" && (function() {
-    function r(h, f) {
-      return h === f && (h !== 0 || 1 / h === 1 / f) || h !== h && f !== f;
+function ct(t) {
+  const { schema: e, ...s } = t;
+  return U({
+    ...s,
+    ...e !== void 0 ? { compiled: ae(e, t.model) } : {}
+  });
+}
+function He(t) {
+  k(t).dispose();
+}
+function U(t) {
+  const { model: e, compiled: s, behavior: i } = t, n = s ?? Ge;
+  for (const [o, c] of n.arrays)
+    c.initialValue !== void 0 && pe(o, c.initialValue);
+  const a = le(
+    e.$,
+    n
+  ), r = a.proxy;
+  if (O(e.$, r), i)
+    try {
+      a.attachBehaviorCleanup(
+        i.__run(e, r, t.schemaController, t.flow)
+      );
+    } catch (o) {
+      throw a.dispose(), o;
     }
-    function e(h, f) {
-      v || i.startTransition === void 0 || (v = !0, console.error(
-        "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
-      ));
-      var m = f();
-      if (!o) {
-        var b = f();
-        a(m, b) || (console.error(
-          "The result of getSnapshot should be cached to avoid an infinite loop"
-        ), o = !0);
+  return r;
+}
+const C = "[@reformer/core] FormFlow";
+function Je(t) {
+  const e = [...t.steps];
+  if (e.length === 0) throw new Error(`${C}: у потока нет шагов.`);
+  const s = e.filter((u, f) => e.indexOf(u) !== f);
+  if (s.length > 0)
+    throw new Error(`${C}: шаги повторяются: ${[...new Set(s)].join(", ")}.`);
+  const i = w(0), n = w(/* @__PURE__ */ new Set()), a = w(0);
+  let r = 0;
+  const o = (u) => e.indexOf(u), c = (u) => {
+    const f = o(u);
+    if (f < 0)
+      throw new Error(`${C}: шага «${u}» нет. Шаги потока: ${e.join(", ")}.`);
+    return f;
+  }, l = (u) => {
+    const f = e[i.peek()];
+    return r++, D(() => {
+      u < i.peek() && (n.value = new Set([...n.peek()].filter((p) => o(p) < u))), i.value = u;
+    }), { status: "moved", from: f, to: e[u] };
+  }, h = (u) => {
+    const f = o(u);
+    return f < 0 ? !1 : f === 0 || n.value.has(e[f - 1]);
+  };
+  return {
+    steps: e,
+    current: d(() => e[i.value]),
+    // Наружу — только чтение: шаг меняют переходы потока.
+    index: d(() => i.value),
+    completed: d(() => n.value),
+    isFirst: d(() => i.value === 0),
+    isLast: d(() => i.value === e.length - 1),
+    validating: d(() => a.value > 0),
+    canGoTo: h,
+    async next() {
+      const u = i.peek(), f = r, p = e[u];
+      let y;
+      if (t.validateStep) {
+        a.value++;
+        try {
+          y = await t.validateStep(p);
+        } finally {
+          a.value--;
+        }
       }
-      b = n({
-        inst: { value: m, getSnapshot: f }
+      const S = y !== void 0 ? { validation: y } : {};
+      return r !== f ? { status: "stayed", step: e[i.peek()], reason: "cancelled", ...S } : y !== void 0 && y.status !== "valid" ? { status: "stayed", step: p, reason: y.status, ...S } : (n.value = /* @__PURE__ */ new Set([...n.peek(), p]), u === e.length - 1 ? { status: "stayed", step: p, reason: "edge", ...S } : (r++, i.value = u + 1, { status: "moved", from: p, to: e[u + 1] }));
+    },
+    previous() {
+      const u = i.peek();
+      return u === 0 ? { status: "stayed", step: e[0], reason: "edge" } : l(u - 1);
+    },
+    goTo(u) {
+      const f = c(u);
+      return f === i.peek() ? { status: "stayed", step: u, reason: "current" } : h(u) ? l(f) : { status: "stayed", step: e[i.peek()], reason: "locked" };
+    },
+    reset() {
+      r++, D(() => {
+        i.value = 0, n.value = /* @__PURE__ */ new Set();
       });
-      var y = b[0].inst, k = b[1];
-      return d(
-        function() {
-          y.value = m, y.getSnapshot = f, t(y) && k({ inst: y });
-        },
-        [h, m, f]
-      ), l(
-        function() {
-          return t(y) && k({ inst: y }), h(function() {
-            t(y) && k({ inst: y });
-          });
-        },
-        [h]
-      ), u(m), m;
     }
-    function t(h) {
-      var f = h.getSnapshot;
-      h = h.value;
+  };
+}
+function Xe(t) {
+  const e = w(0);
+  return {
+    submitting: d(() => e.value > 0),
+    async submit(s) {
+      const i = await t.check?.();
+      if (i) {
+        const { result: a } = i;
+        if (a.status !== "valid") return { status: a.status, validation: a };
+        if (i.stale)
+          return { status: "cancelled", validation: { ...a, status: "cancelled" } };
+      }
+      const n = i ? i.values : t.values();
+      e.value++;
       try {
-        var m = f();
-        return !a(h, m);
-      } catch {
-        return !0;
+        return { status: "submitted", result: await s(n) };
+      } catch (a) {
+        return { status: "failed", error: a };
+      } finally {
+        e.value--;
       }
     }
-    function s(h, f) {
-      return f();
-    }
-    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
-    var i = K, a = typeof Object.is == "function" ? Object.is : r, n = i.useState, l = i.useEffect, d = i.useLayoutEffect, u = i.useDebugValue, v = !1, o = !1, p = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? s : e;
-    T.useSyncExternalStore = i.useSyncExternalStore !== void 0 ? i.useSyncExternalStore : p, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
-  })()), T;
-}
-var H;
-function ye() {
-  return H || (H = 1, process.env.NODE_ENV === "production" ? N.exports = pe() : N.exports = me()), N.exports;
-}
-var C = ye();
-function ge(r, e) {
-  if (r === e) return !0;
-  if (r.length !== e.length) return !1;
-  for (let t = 0; t < r.length; t++)
-    if (r[t] !== e[t]) return !1;
-  return !0;
+  };
 }
-function R(r, e, t, s) {
-  const i = O(null), a = O(r);
-  a.current = r;
-  const n = O(e);
-  n.current = e;
-  const l = O(t);
-  if (l.current = t, i.current === null) {
-    const v = {};
-    for (const o in r)
-      v[o] = r[o].value;
-    i.current = { ...v, __snapshot: null };
-  }
-  const d = _(
-    (v) => {
-      let o = !0;
-      return E(() => {
-        const h = a.current;
-        for (const f in h)
-          h[f].value;
-        if (o) {
-          o = !1;
-          return;
-        }
-        v();
-      });
-    },
-    [s]
-  ), u = _(() => {
-    const v = i.current, o = a.current, p = {};
-    for (const f in o)
-      p[f] = o[f].value;
-    let h = !1;
-    for (const f of n.current) {
-      const { key: m, useShallowArrayEqual: b } = f, y = p[m], k = v[m];
-      if (b) {
-        if (!ge(k, y)) {
-          h = !0;
-          break;
-        }
-      } else if (k !== y) {
-        h = !0;
-        break;
-      }
+const M = Object.freeze({
+  status: "valid",
+  issues: /* @__PURE__ */ new Map(),
+  failures: []
+}), G = "[@reformer/core] createForm";
+function Qe(t, e) {
+  const s = typeof e.validation == "function" ? { rules: e.validation } : e.validation ?? {}, i = /* @__PURE__ */ new Map();
+  for (const v of e.flow?.steps ?? []) {
+    if (i.has(v.id)) throw new Error(`${G}: шаг потока «${v.id}» повторяется.`);
+    i.set(v.id, v.rules ?? null);
+  }
+  const n = [...i.values()].filter(
+    (v) => v != null
+  ), a = s.rules ?? (n.length > 0 || s.extras ? Pe(
+    () => Fe(...n, ...s.extras ? [s.extras] : [])
+  ) : void 0), r = a !== void 0 ? Ae(t, a, {
+    strategy: s.strategy,
+    debounce: s.debounce,
+    liveAfterSubmit: s.liveAfterSubmit
+  }) : void 0, o = w(0), c = (v) => {
+    const m = we();
+    return m ? (o.value++, m.then(v).finally(() => {
+      o.value--;
+    })) : v();
+  }, l = async (v) => {
+    let m;
+    const $ = await c(() => (m = t.get(), v())), P = t.get();
+    return { result: $, values: P, stale: $.status === "valid" && !ye(m, P) };
+  }, h = () => r ? c(() => r.run()) : Promise.resolve(M), u = (v) => {
+    if (!i.has(v)) {
+      const m = [...i.keys()];
+      throw new Error(
+        `${G}: шага «${v}» нет в потоке. ` + (m.length > 0 ? `Шаги потока: ${m.join(", ")}.` : "Поток не задан: `flow`.")
+      );
+    }
+    return i.get(v) ?? null;
+  }, f = async (v) => {
+    o.value++;
+    try {
+      return await Ie(t, v, { touch: !0, skipDisabled: !0 });
+    } finally {
+      o.value--;
+    }
+  }, p = async (v) => {
+    const m = u(v);
+    return m ? c(() => f(m)) : M;
+  }, y = async (v) => {
+    const m = u(v);
+    if (!m) return M;
+    const { result: $, stale: P } = await l(() => f(m));
+    return P ? { ...$, status: "cancelled" } : $;
+  }, S = e.flow !== void 0 ? Je({ steps: [...i.keys()], validateStep: y }) : void 0, ce = Xe({
+    check: r ? () => l(() => r.run({ touch: "all", submit: !0 })) : void 0,
+    values: () => t.get()
+  });
+  return {
+    flow: S,
+    validating: d(() => (r?.validating.value ?? !1) || o.value > 0),
+    validation: a !== void 0 && r ? { rules: a, controller: r } : void 0,
+    submission: ce,
+    validate: h,
+    validateStep: p,
+    dispose() {
+      r?.dispose();
+      for (const v of n) Oe(t, v);
     }
-    if (!h && v.__snapshot)
-      return v.__snapshot;
-    for (const f in o)
-      v[f] = p[f];
-    return v.__snapshot = l.current(p), v.__snapshot;
-  }, [s]);
-  return C.useSyncExternalStore(d, u, u);
+  };
 }
-function be(r) {
-  const e = {
-    value: r.value,
-    disabled: r.disabled,
-    errors: r.errors,
-    pending: r.pending,
-    valid: r.valid,
-    invalid: r.invalid,
-    touched: r.touched,
-    dirty: r.dirty,
-    shouldShowError: r.shouldShowError,
-    componentProps: r.componentProps
-  }, t = [
-    { key: "value" },
-    { key: "disabled" },
-    { key: "errors", useShallowArrayEqual: !0 },
-    { key: "pending" },
-    { key: "valid" },
-    { key: "invalid" },
-    { key: "touched" },
-    { key: "dirty" },
-    { key: "shouldShowError" },
-    { key: "componentProps" }
-  ], s = _(
-    (i) => ({
-      value: i.value,
-      pending: i.pending,
-      disabled: i.disabled,
-      errors: i.errors,
-      valid: i.valid,
-      invalid: i.invalid,
-      touched: i.touched,
-      dirty: i.dirty,
-      shouldShowError: i.shouldShowError,
-      componentProps: i.componentProps
-    }),
-    []
-  );
-  return R(e, t, s, r);
+const E = "[@reformer/core] createForm", Y = (t) => t.map((e) => `"${e}"`).join(", ");
+function Ze(t, e, s) {
+  if (t === void 0) return;
+  const i = Ee(e, t);
+  if (i.length > 0 && console.warn(
+    `${E}: поведение обращается к узлам схемы, которых нет в корневом дереве: ${Y(i)}. Правило ничего не сделает. Узлы строки массива и подформы адресуются из их поведения — через \`applyEach\` / \`apply\`.`
+  ), s) {
+    const n = s.steps.map((r) => r.id), a = n.filter((r) => t.nodes.get(r)?.selector !== r);
+    a.length > 0 && a.length < n.length && console.warn(
+      `${E}: в \`flow.steps\` есть шаги, для которых в дереве схемы нет узла с таким \`selector\`: ${Y(a)}. Визард не свяжет их с разметкой шага.`
+    );
+  }
 }
-function Ee(r) {
-  const e = {
-    value: r.value,
-    length: r.length,
-    errors: r.errors,
-    pending: r.pending,
-    valid: r.valid,
-    invalid: r.invalid,
-    touched: r.touched,
-    dirty: r.dirty,
-    disabled: r.disabled
-  }, t = [
-    { key: "value" },
-    { key: "length" },
-    { key: "errors", useShallowArrayEqual: !0 },
-    { key: "pending" },
-    { key: "valid" },
-    { key: "invalid" },
-    { key: "touched" },
-    { key: "dirty" },
-    { key: "disabled" }
-  ], s = _(
-    (i) => ({
-      value: i.value,
-      length: i.length,
-      pending: i.pending,
-      errors: i.errors,
-      valid: i.valid,
-      invalid: i.invalid,
-      touched: i.touched,
-      dirty: i.dirty,
-      disabled: i.disabled
-    }),
-    []
-  );
-  return R(e, t, s, r);
+function et(t, e) {
+  const { schema: s, registry: i } = t;
+  if (s == null) return {};
+  if (typeof s == "function")
+    return { tree: s(e) };
+  if (i == null)
+    throw new Error(
+      `${E}: \`schema\` — готовое дерево, а не билдер \`(model) => узел\`. Передайте билдер; документу схемы (JSON) нужен \`registry\`. Форму из модели и готового дерева без сборки собирает \`createFormFromModel({ model, schema })\`.`
+    );
+  if (typeof i.resolveSchema != "function")
+    throw new Error(
+      `${E}: \`registry\` не умеет собирать дерево из документа схемы — у него нет метода \`resolveSchema\`. Возьмите реестр \`@reformer/renderer-json\` (\`createComponentRegistry\`).`
+    );
+  return i.resolveSchema(s, e);
 }
-function _e() {
-  const r = _(
-    () => ({
-      value: [],
-      length: 0,
-      pending: !1,
-      errors: [],
-      valid: !0,
-      invalid: !1,
-      touched: !1,
-      dirty: !1,
-      disabled: !1
-    }),
-    []
+function ut(t) {
+  if (typeof t?.model?.signalAt != "function" && t?.initial === void 0)
+    throw new Error(
+      `${E}: нужна модель — \`model\` либо \`initial\`. Значения формы принадлежат модели: \`createForm({ initial: { email: '' }, schema })\`.`
+    );
+  const s = t.model ?? ue(t.initial);
+  t.seed?.(s);
+  const { tree: i, fieldWrapper: n, errorBoundary: a } = et(t, s), r = i !== void 0 ? ae(i, s) : void 0, o = $e(), c = o.scopeOf(s), l = Qe(s, { validation: t.validation, flow: t.flow }), h = be(
+    () => U({
+      model: s,
+      ...r !== void 0 ? { compiled: r } : {},
+      ...t.behavior ? { behavior: t.behavior, schemaController: o } : {},
+      ...l.flow !== void 0 ? { flow: l.flow } : {}
+    })
   );
-  return R({}, [], r);
-}
-function Me(r) {
-  const e = r && "length" in r && "map" in r;
-  return r ? e ? Ee(r) : be(r) : _e();
-}
-function xe(r) {
-  const e = O({ value: r.value.value }), t = _(
-    (i) => {
-      let a = !0;
-      return E(() => {
-        if (r.value.value, a) {
-          a = !1;
-          return;
-        }
-        i();
-      });
-    },
-    [r]
-  ), s = _(() => {
-    const i = r.value.value;
-    return e.current.value === i ? e.current.value : (e.current.value = i, i);
-  }, [r]);
-  return C.useSyncExternalStore(t, s, s);
-}
-function Ce(r) {
-  const e = O({ length: r.length.value }), t = _(
-    (i) => {
-      let a = !0;
-      return E(() => {
-        if (r.length.value, a) {
-          a = !1;
-          return;
-        }
-        i();
-      });
+  t.model === void 0 && s.captureInitial(), process.env.NODE_ENV !== "production" && Ze(r, c.__overrideMaps, t.flow);
+  const u = {
+    ...l,
+    model: s,
+    form: h,
+    render: {
+      tree: r,
+      controller: o,
+      node: (f) => c.node(f),
+      ...n !== void 0 ? { fieldWrapper: n } : {},
+      ...a !== void 0 ? { errorBoundary: a } : {}
     },
-    [r]
-  ), s = _(() => {
-    const i = r.length.value;
-    return e.current.length === i ? e.current.length : (e.current.length = i, i);
-  }, [r]);
-  return C.useSyncExternalStore(t, s, s);
-}
-function Pe(r) {
-  const { model: e, schema: t, strategy: s, debounce: i, liveAfterSubmit: a } = r, n = ee(
-    () => se(e, t, { strategy: s, debounce: i, liveAfterSubmit: a }),
-    [e, t, s, i, a]
-  );
-  te(() => n.start(), [n]);
-  const l = C.useSyncExternalStore(
-    _((u) => n.validating.subscribe(u), [n]),
-    () => n.validating.peek(),
-    () => !1
-    // SSR: прогон не идёт
-  ), d = _(() => n.validate(), [n]);
-  return { submit: d, validate: d, isValidating: l };
+    // После `...level`: уровень снимает только себя, сборка — ещё и форму.
+    dispose() {
+      He(h), l.dispose();
+    }
+  };
+  try {
+    t.setup?.(u);
+  } catch (f) {
+    throw u.dispose(), f;
+  }
+  return u;
 }
+const dt = Object.freeze({ runtime: "reformer-core", v: 1 });
 export {
-  U as ArrayNode,
-  A as ErrorStrategy,
-  ae as FieldNode,
-  F as FormErrorHandler,
-  M as FormNode,
-  re as FormStatusMachine,
-  oe as FormSubmitter,
-  S as GroupNode,
-  de as ModelArrayNode,
-  ue as NodeFactory,
-  I as SubscriptionManager,
-  Re as computeFrom,
-  Be as copyFrom,
-  Oe as createForm,
-  Q as createFormFromModel,
-  Ie as createModel,
-  st as disableWhen,
-  it as enableWhen,
-  et as getNodeForSignal,
-  Ne as getNodeType,
-  ve as isArrayNode,
-  B as isDerived,
-  ce as isFieldNode,
-  x as isFormNode,
-  fe as isGroupNode,
-  Ye as markDerived,
-  Z as registerSignalNode,
-  $e as resetWhen,
-  Ge as revalidateWhen,
-  je as runOutsideEffect,
-  Ue as safeCallback,
-  We as safeDebouncedCallback,
-  qe as syncFields,
-  He as transformValue,
-  V as uniqueId,
-  ze as unmarkDerived,
-  Ce as useArrayLength,
-  Me as useFormControl,
-  xe as useFormControlValue,
-  Pe as useFormValidation,
-  Xe as validators,
-  Ke as watchField
+  dt as CORE_RUNTIME_TOKEN,
+  wt as arrayOf,
+  ae as compileSchema,
+  ut as createForm,
+  Je as createFormFlow,
+  ct as createFormFromModel,
+  Qe as createFormLevel,
+  ue as createModel,
+  $e as createSchemaController,
+  At as createSchemaScope,
+  Xe as createSubmission,
+  He as disposeForm,
+  vt as eachLeafSignal,
+  pt as eachValueSignal,
+  Et as getNodeForSignal,
+  lt as isCompiledNode,
+  T as isDerived,
+  Ft as isFormArray,
+  It as isFormControl,
+  Nt as isFormGroup,
+  Vt as isFormNode,
+  X as isModelContainerSignal,
+  J as isValueSignal,
+  yt as markDerived,
+  _ as modelOf,
+  O as registerSignalNode,
+  bt as runOutsideEffect,
+  gt as safeCallback,
+  kt as safeDebouncedCallback,
+  ee as schemaSubtree,
+  Ee as unknownSchemaSelectors,
+  St as unmarkDerived
 };