@reformer/core 11.0.0-beta.7 → 11.0.0-beta.9

package/dist/index.js

@@ -1,2922 +1,1082 @@
-import { c as K } from "./create-model-B8U-COv-.js";
-import { e as He, a as Ke } from "./create-model-B8U-COv-.js";
-import { b as R, d as L, a as $ } from "./model-signals-proxy-2vqS243J.js";
-import { i as Ye, m as Je, u as Qe } from "./model-signals-proxy-2vqS243J.js";
-import { c as Ze, a as et, r as tt, b as st, d as it, e as rt, f as nt, s as at, t as ot, w as lt } from "./behaviors-value-C7dSEhCc.js";
-import { signal as m, computed as h, effect as g, batch as z, Signal as Y } from "@preact/signals-core";
-import { r as J } from "./signal-node-registry-tiwel-TV.js";
-import { g as dt } from "./signal-node-registry-tiwel-TV.js";
-import { f as Q, h as P, g as X, d as Z } from "./strategy-BXS_gBfz.js";
-import { d as ht, e as ft } from "./node-DGEFMTQu.js";
-import { useRef as _, useCallback as y, useMemo as ee, useEffect as U, useState as te, useImperativeHandle as se } from "react";
-import { s as F } from "./index-BrNkQj1y.js";
-class N {
-  // ============================================================================
-  // Protected состояние (для Template Method паттерна)
-  // ============================================================================
-  /**
-   * Пользователь взаимодействовал с узлом (touched)
-   * Protected: наследники могут читать/изменять через методы
-   */
-  _touched = m(!1);
-  /**
-   * Значение узла было изменено (dirty)
-   * Protected: наследники могут читать/изменять через методы
-   */
-  _dirty = m(!1);
-  /**
-   * Текущий статус узла
-   * Protected: наследники могут читать/изменять через методы
-   */
-  _status = m("valid");
-  // ============================================================================
-  // Публичные computed signals (readonly для внешнего мира)
-  // ============================================================================
-  /**
-   * Пользователь взаимодействовал с узлом (touched)
-   * Computed из _touched для предоставления readonly интерфейса
-   */
-  touched = h(() => this._touched.value);
-  /**
-   * Значение узла было изменено (dirty)
-   * Computed из _dirty для предоставления readonly интерфейса
-   */
-  dirty = h(() => this._dirty.value);
-  /**
-   * Текущий статус узла
-   * Computed из _status для предоставления readonly интерфейса
-   */
-  status = h(() => this._status.value);
-  /**
-   * Узел отключен (disabled)
-   */
-  disabled = h(() => 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((i) => {
-      if (e.code !== void 0 && !(Array.isArray(e.code) ? e.code : [e.code]).includes(i.code) || e.message !== void 0 && !i.message.toLowerCase().includes(e.message.toLowerCase()))
-        return !1;
-      if (e.params !== void 0) {
-        if (!i.params)
-          return !1;
-        for (const [r, n] of Object.entries(e.params))
-          if (i.params[r] !== n)
-            return !1;
-      }
-      return !(e.predicate !== void 0 && !e.predicate(i));
-    }) : 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-BvcbNPgL.js";
+import { e as ft, a as vt } from "./create-model-BvcbNPgL.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 } from "./safe-effect-BbtX3KuN.js";
+import { a as mt, c as wt, r as yt, s as bt, e as gt, u as kt } from "./safe-effect-BbtX3KuN.js";
+import { signal as w, computed as d, batch as D, effect as be, untracked as A } from "@preact/signals-core";
+import { N as j, R as ge, k as ke, r as k } from "./node-kind-C-r6ZMdo.js";
+import { r as O } from "./signal-node-registry-tiwel-TV.js";
+import { g as $t } from "./signal-node-registry-tiwel-TV.js";
+import { c as Se, u as $e } from "./schema-controller-CpiO2JoK.js";
+import { a as Pt } from "./schema-controller-CpiO2JoK.js";
+import { e as Ee, h as Pe, i as Ae, c as Oe, j as Fe } from "./strategy-CoFSemuP.js";
+import { c as Ot, a as Ft, b as It, i as Nt } from "./type-guards-D-N_5Ddh.js";
+function Ie() {
+  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;
+    }
+  };
 }
-class x {
-  /**
-   * Хранилище подписок
-   * Ключ: уникальный идентификатор подписки
-   * Значение: функция отписки (dispose)
-   */
-  subscriptions = /* @__PURE__ */ new Map();
-  /**
-   * Добавляет подписку
-   *
-   * Если подписка с таким ключом уже существует, отписывается от неё
-   * и заменяет новой. Это предотвращает утечки памяти при повторной
-   * регистрации подписки с тем же ключом.
-   *
-   * @param key Уникальный ключ подписки
-   * @param dispose Функция отписки (обычно возвращаемая из effect())
-   * @returns Функция для отписки от этой конкретной подписки
-   *
-   * @example
-   * ```typescript
-   * const manager = new SubscriptionManager();
-   *
-   * // Добавление подписки
-   * const unsubscribe = manager.add('mySubscription', () => {
-   *   console.log('Disposing subscription');
-   * });
-   *
-   * // Отписка через возвращаемую функцию
-   * unsubscribe();
-   *
-   * // Или через manager.remove()
-   * manager.add('anotherSub', disposeFn);
-   * manager.remove('anotherSub');
-   * ```
-   */
-  add(e, t) {
-    return this.subscriptions.has(e) && (process.env.NODE_ENV !== "production" && console.warn(`[SubscriptionManager] Subscription "${e}" already exists, replacing`), this.subscriptions.get(e)?.()), this.subscriptions.set(e, t), () => this.remove(e);
-  }
-  /**
-   * Удаляет подписку по ключу
-   *
-   * Вызывает функцию отписки и удаляет подписку из хранилища.
-   * Если подписка с таким ключом не найдена, ничего не делает.
-   *
-   * @param key Ключ подписки
-   * @returns true, если подписка была удалена, false если не найдена
-   *
-   * @example
-   * ```typescript
-   * const manager = new SubscriptionManager();
-   * manager.add('mySub', disposeFn);
-   *
-   * // Удаление подписки
-   * const removed = manager.remove('mySub'); // true
-   *
-   * // Попытка удалить несуществующую подписку
-   * const removed2 = manager.remove('nonExistent'); // false
-   * ```
-   */
-  remove(e) {
-    const t = this.subscriptions.get(e);
-    return t ? (t(), this.subscriptions.delete(e), !0) : !1;
-  }
-  /**
-   * Очищает все подписки
-   *
-   * Вызывает функции отписки для всех активных подписок
-   * и очищает хранилище. Обычно используется при dispose узла формы.
-   *
-   * @example
-   * ```typescript
-   * class FieldNode {
-   *   private subscriptions = new SubscriptionManager();
-   *
-   *   dispose() {
-   *     // Отписываемся от всех effect
-   *     this.subscriptions.clear();
-   *   }
-   * }
-   * ```
-   */
-  clear() {
-    this.subscriptions.forEach((e) => {
-      e();
-    }), this.subscriptions.clear();
-  }
-  /**
-   * Возвращает количество активных подписок
-   *
-   * Полезно для отладки утечек памяти. Если количество подписок
-   * растет без ограничений, это может указывать на то, что
-   * компоненты не отписываются должным образом.
-   *
-   * @returns Количество активных подписок
-   *
-   * @example
-   * ```typescript
-   * const manager = new SubscriptionManager();
-   * console.log(manager.size()); // 0
-   *
-   * manager.add('sub1', disposeFn1);
-   * manager.add('sub2', disposeFn2);
-   * console.log(manager.size()); // 2
-   *
-   * manager.clear();
-   * console.log(manager.size()); // 0
-   * ```
-   */
-  size() {
-    return this.subscriptions.size;
-  }
-  /**
-   * Проверяет, есть ли подписка с данным ключом
-   *
-   * @param key Ключ подписки
-   * @returns true, если подписка существует
-   *
-   * @example
-   * ```typescript
-   * const manager = new SubscriptionManager();
-   * manager.add('mySub', disposeFn);
-   *
-   * console.log(manager.has('mySub')); // true
-   * console.log(manager.has('nonExistent')); // false
-   * ```
-   */
-  has(e) {
-    return this.subscriptions.has(e);
-  }
-  /**
-   * Возвращает список всех ключей активных подписок
-   *
-   * Полезно для отладки: можно увидеть, какие подписки активны.
-   *
-   * @returns Массив ключей всех активных подписок
-   *
-   * @example
-   * ```typescript
-   * const manager = new SubscriptionManager();
-   * manager.add('watch-value', disposeFn1);
-   * manager.add('watch-errors', disposeFn2);
-   *
-   * console.log(manager.getKeys()); // ['watch-value', 'watch-errors']
-   * ```
-   */
-  getKeys() {
-    return Array.from(this.subscriptions.keys());
-  }
-  /**
-   * Отписывается от всех подписок (алиас для clear())
-   *
-   * Используется при dispose() узла формы для совместимости с ожидаемым API.
-   *
-   * @example
-   * ```typescript
-   * class FieldNode {
-   *   private subscriptions = new SubscriptionManager();
-   *
-   *   dispose() {
-   *     this.subscriptions.dispose();
-   *   }
-   * }
-   * ```
-   */
-  dispose() {
-    this.clear();
-  }
+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 = [];
+    }
+  };
 }
-const k = {
-  /** FieldNode.watch() */
-  Watch: "watch",
-  /** FieldNode.computeFrom() */
-  ComputeFrom: "computeFrom",
-  /** GroupNode.linkFields() */
-  LinkFields: "linkFields",
-  /** GroupNode.watchField() */
-  WatchField: "watchField"
-};
-let ie = 0;
-function V(s) {
-  return `${s}-${++ie}`;
+function K(t = !1) {
+  const e = w(t);
+  return {
+    disabled: d(() => e.value),
+    setDisabled: (s) => {
+      e.value = s;
+    }
+  };
 }
-var E = /* @__PURE__ */ ((s) => (s.THROW = "throw", s.LOG = "log", s.CONVERT = "convert", s))(E || {});
-class w {
-  static handle(e, t, i = "throw") {
-    const r = this.extractMessage(e);
-    switch (process.env.NODE_ENV !== "production" && console.error(`[${t}]`, e), i) {
-      case "throw":
-        throw e;
-      case "log":
-        return;
-      case "convert":
-        return {
-          code: "validator_error",
-          message: r,
-          params: { field: t }
-        };
+function W() {
+  const t = w(0);
+  return {
+    active: d(() => t.value > 0),
+    mark: (e) => {
+      t.value = Math.max(0, t.peek() + (e ? 1 : -1));
     }
-  }
-  /**
-   * Извлечь сообщение из ошибки
-   *
-   * Обрабатывает различные типы ошибок:
-   * - 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, i) {
-    return {
-      code: e,
-      message: t,
-      params: i ? { field: i } : void 0
-    };
-  }
-  /**
-   * Проверить, является ли объект ValidationError
-   *
-   * Type guard для ValidationError
-   *
-   * @param value Значение для проверки
-   * @returns true если value является ValidationError
-   *
-   * @example
-   * ```typescript
-   * if (FormErrorHandler.isValidationError(result)) {
-   *   console.log(result.code); // OK, типобезопасно
-   * }
-   * ```
-   */
-  static isValidationError(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 = m(e), this.status = h(() => this._status.value), this.valid = h(() => this._status.value === "valid"), this.invalid = h(() => this._status.value === "invalid"), this.pending = h(() => this._status.value === "pending"), this.disabled = h(() => 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";
-  }
+function Ne(t = {}) {
+  const e = w(t);
+  return {
+    props: d(() => e.value),
+    update: (s) => {
+      e.value = { ...e.peek(), ...s };
+    }
+  };
 }
-class ne extends N {
-  // ============================================================================
-  // Приватные сигналы
-  // ============================================================================
-  _value;
-  _errors;
-  // _touched, _dirty наследуются от FormNode (protected)
-  // _status управляется через statusMachine
-  _componentProps;
-  /**
-   * State machine для управления статусом поля
-   * Централизует логику переходов между valid/invalid/pending/disabled
-   */
-  statusMachine;
-  // ============================================================================
-  // Публичные computed signals
-  // ============================================================================
+class Ve {
+  [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;
-  /**
-   * Pending debounced validation state
-   * Contains resolve function and AbortController for cancellation
-   */
-  pendingValidation;
-  /**
-   * Менеджер подписок для централизованного cleanup
-   * Использует SubscriptionManager вместо массива для управления подписками
-   */
-  disposers = new x();
-  component;
-  // ============================================================================
-  // Конструктор
-  // ============================================================================
-  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 ?? m(e.value), this.initialValue = this._value.peek(), this._errors = m([]), this._componentProps = m(e.componentProps || {}), this.statusMachine = new re(e.disabled ? "disabled" : "valid"), this.value = h(() => this._value.value), this.valid = h(() => this.statusMachine.valid.value), this.invalid = h(() => this.statusMachine.invalid.value), this.pending = h(() => this.statusMachine.pending.value), this.status = h(() => this.statusMachine.status.value), this.disabled = h(() => this.statusMachine.disabled.value), this.errors = h(() => this._errors.value), this.componentProps = h(() => this._componentProps.value), this.shouldShowError = h(
-      () => this.statusMachine.invalid.value && (this._touched.value || this._dirty.value)
-    );
-  }
-  // ============================================================================
-  // Реализация абстрактных методов FormNode
-  // ============================================================================
-  getValue() {
-    return this._value.peek();
-  }
-  setValue(e, t) {
-    if (this._value.value = e, this._dirty.value = !0, t?.emitEvent === !1)
-      return;
-    const i = this.validators.length > 0 || this.asyncValidators.length > 0, r = this._errors.value.length > 0;
-    if (this.updateOn === "change") {
-      this.validate();
-      return;
-    }
-    r && i && this.validate();
-  }
-  patchValue(e) {
-    this.setValue(e);
-  }
-  /**
-   * Сбросить поле к указанному значению (или к initialValue)
-   *
-   * @param value - опциональное значение для сброса. Если не указано, используется initialValue
-   *
-   * @remarks
-   * Этот метод:
-   * - Устанавливает значение в value или initialValue
-   * - Очищает ошибки валидации
-   * - Сбрасывает touched/dirty флаги
-   * - Устанавливает статус в 'valid'
-   *
-   * Если вам нужно сбросить к исходному значению, используйте resetToInitial()
-   *
-   * @example
-   * ```typescript
-   * // Сброс к initialValue
-   * field.reset();
-   *
-   * // Сброс к новому значению
-   * field.reset('new value');
-   * ```
-   */
-  reset(e) {
-    this._value.value = e !== void 0 ? e : this.initialValue, this._errors.value = [], this._touched.value = !1, this._dirty.value = !1, this.statusMachine.setErrors(!1);
-  }
-  /**
-   * Сбросить поле к исходному значению (initialValue)
-   *
-   * @remarks
-   * Алиас для reset() без параметров, но более явный:
-   * - resetToInitial() - явно показывает намерение вернуться к начальному значению
-   * - reset() - может принимать новое значение
-   *
-   * Полезно когда:
-   * - Пользователь нажал "Cancel" - вернуть форму в исходное состояние
-   * - Форма была изменена через reset(newValue), но нужно вернуться к самому началу
-   * - Явное намерение показать "отмену всех изменений"
-   *
-   * @example
-   * ```typescript
-   * const field = new FieldNode({ value: 'initial', component: Input });
-   *
-   * field.setValue('changed');
-   * field.reset('temp value');
-   * console.log(field.value.value); // 'temp value'
-   *
-   * field.resetToInitial();
-   * console.log(field.value.value); // 'initial'
-   * ```
-   */
-  resetToInitial() {
-    this.reset(this.initialValue);
-  }
-  /**
-   * Cancel any pending validation (debounced or running)
-   * @private
-   * @remarks
-   * Centralizes all cancellation logic:
-   * - Aborts pending debounced validation and resolves its promise
-   * - Clears debounce timer
-   * - Aborts currently running async validation
-   */
-  cancelPendingValidation() {
-    this.pendingValidation && (this.pendingValidation.abortController.abort(), this.pendingValidation.resolve(!1), this.pendingValidation = void 0), this.validateDebounceTimer && (clearTimeout(this.validateDebounceTimer), this.validateDebounceTimer = void 0), this.currentAbortController && (this.currentAbortController.abort(), this.currentAbortController = void 0);
-  }
-  /**
-   * Запустить валидацию поля
-   * @param options - опции валидации
-   * @returns `Promise<boolean>` - true если поле валидно
-   *
-   * @remarks
-   * Метод защищен от race conditions через AbortController.
-   * При быстром вводе только последняя валидация применяет результаты.
-   *
-   * @example
-   * ```typescript
-   * // Обычная валидация
-   * await field.validate();
-   *
-   * // С debounce
-   * await field.validate({ debounce: 300 });
-   * ```
-   */
-  async validate(e) {
-    const t = e?.debounce ?? this.debounceMs;
-    if (this.cancelPendingValidation(), t <= 0 || this.asyncValidators.length === 0)
-      return this.validateImmediate();
-    const i = new AbortController();
-    return new Promise((r) => {
-      this.pendingValidation = { resolve: r, abortController: i }, this.validateDebounceTimer = setTimeout(async () => {
-        if (this.validateDebounceTimer = void 0, i.signal.aborted) {
-          r(!1);
-          return;
-        }
-        this.pendingValidation = void 0;
-        const n = await this.validateImmediate(i);
-        r(n);
-      }, t), i.signal.addEventListener(
-        "abort",
-        () => {
-          this.validateDebounceTimer && (clearTimeout(this.validateDebounceTimer), this.validateDebounceTimer = void 0), r(!1);
-        },
-        { once: !0 }
-      );
-    });
-  }
-  /**
-   * Немедленная валидация без debounce
-   * @private
-   * @param providedController - AbortController from debounced validate()
-   * @remarks
-   * Защищена от race conditions через AbortController:
-   * - Отменяет предыдущую валидацию при запуске новой (if no controller provided)
-   * - Передаёт AbortSignal в async валидаторы для отмены операций (например, fetch)
-   * - Проверяет signal.aborted в ключевых точках
-   */
-  async validateImmediate(e) {
-    const t = e ?? new AbortController();
-    e || this.currentAbortController?.abort(), this.currentAbortController = t;
-    const { signal: i } = t, r = [];
-    for (const a of this.validators) {
-      const u = a(this._value.value);
-      u && r.push(u);
-    }
-    if (i.aborted)
-      return !1;
-    if (r.length > 0) {
-      this._errors.value = r;
-      const a = r.some((u) => u.severity !== "warning");
-      if (this.statusMachine.setErrors(a), a)
-        return !1;
-    }
-    if (this.asyncValidators.length > 0) {
-      if (i.aborted)
-        return !1;
-      this.statusMachine.startValidation();
-      try {
-        const a = await Promise.all(
-          this.asyncValidators.map(async (d) => {
-            if (i.aborted)
-              throw new DOMException("Validation aborted", "AbortError");
-            try {
-              const l = await d(this._value.value, { signal: i });
-              if (i.aborted)
-                throw new DOMException("Validation aborted", "AbortError");
-              return l;
-            } catch (l) {
-              if (l instanceof DOMException && l.name === "AbortError")
-                throw l;
-              return w.handle(
-                l,
-                "FieldNode AsyncValidator",
-                E.CONVERT
-              );
-            }
-          })
-        );
-        if (i.aborted)
-          return !1;
-        const u = a.filter((d) => d !== null);
-        if (u.length > 0) {
-          this._errors.value = u;
-          const d = u.some((l) => l.severity !== "warning");
-          if (this.statusMachine.completeValidation(d), d)
-            return !1;
-        }
-      } catch (a) {
-        if (a instanceof DOMException && a.name === "AbortError")
-          return !1;
-        throw a;
-      }
-    }
-    return i.aborted ? !1 : ((this.validators.length > 0 || this.asyncValidators.length > 0) && (this._errors.value = [], this.statusMachine.completeValidation(!1)), !this._errors.value.some((a) => a.severity !== "warning"));
-  }
-  setErrors(e) {
-    this._errors.value = e;
-    const t = e.some((i) => i.severity !== "warning");
-    this.statusMachine.setErrors(t);
-  }
-  clearErrors() {
-    this._errors.value = [], this.statusMachine.setErrors(!1);
-  }
-  // ============================================================================
-  // Protected hooks (Template Method pattern)
-  // ============================================================================
-  /**
-   * Hook: вызывается после markAsTouched()
-   *
-   * Для FieldNode: если updateOn === 'blur', запускаем валидацию
-   */
-  onMarkAsTouched() {
-    this.updateOn === "blur" && this.validate();
-  }
-  /**
-   * Hook: вызывается после disable()
-   *
-   * Для FieldNode: синхронизируем statusMachine и очищаем ошибки
-   */
-  onDisable() {
-    this.statusMachine.disable(), this._errors.value = [];
-  }
-  /**
-   * Hook: вызывается после enable()
-   *
-   * Для FieldNode: синхронизируем statusMachine и запускаем валидацию
-   */
-  onEnable() {
-    this.statusMachine.enable(this._errors.value.length > 0), this.validate();
-  }
-  /**
-   * Обновляет свойства компонента (например, опции для Select)
-   *
-   * @example
-   * ```typescript
-   * // Обновление опций для Select после загрузки справочников
-   * form.registrationAddress.city.updateComponentProps({
-   *   options: cities
-   * });
-   * ```
-   */
-  updateComponentProps(e) {
-    this._componentProps.value = {
-      ...this._componentProps.value,
-      ...e
-    };
-  }
-  /**
-   * Динамически изменяет триггер валидации (updateOn)
-   * Полезно для адаптивной валидации - например, переключиться на instant feedback после первого submit
-   *
-   * @param updateOn - новый триггер валидации: 'change' | 'blur' | 'submit'
-   *
-   * @example
-   * Пример node-level: плоская схема с инлайн-значениями (back-compat путь до M1). В layout-схеме
-   * `createForm({ model, schema })` поля `validators` нет — правила живут в `defineValidationSchema`.
-   * ```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;
-  }
-  getUpdateOn() {
-    return this.updateOn;
-  }
-  // ============================================================================
-  // Методы-помощники для реактивности (Фаза 1)
-  // ============================================================================
-  /**
-   * Подписка на изменения значения поля
-   * Автоматически отслеживает изменения через @preact/signals effect
-   *
-   * @param callback - Функция, вызываемая при изменении значения.
-   *   Для async операций передается AbortSignal во втором параметре.
-   * @returns Функция отписки для cleanup
-   *
-   * @example
-   * ```typescript
-   * // Синхронный callback
-   * const unsubscribe = form.email.watch((value) => {
-   *   console.log('Email changed:', value);
-   * });
-   *
-   * // Асинхронный callback с поддержкой отмены
-   * const unsubscribe = form.email.watch(async (value, signal) => {
-   *   const result = await fetch('/api/validate', { signal });
-   *   // ...
-   * });
-   *
-   * // Cleanup
-   * useEffect(() => unsubscribe, []);
-   * ```
-   */
-  watch(e) {
-    const t = new AbortController(), i = g(() => {
-      const n = this.value.value;
-      e(n, t.signal);
-    }), r = V(k.Watch);
-    return this.disposers.add(r, () => {
-      t.abort(), i();
-    });
-  }
-  /**
-   * Вычисляемое значение из других полей
-   * Автоматически обновляет текущее поле при изменении источников
-   *
-   * @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 i = g(() => {
-      const n = e.map((u) => u.value), a = t(...n);
-      this.setValue(a, { emitEvent: !1 });
-    }), r = V(k.ComputeFrom);
-    return this.disposers.add(r, i);
-  }
-  /**
-   * Очистить все ресурсы и таймеры
-   * Должен вызываться при unmount компонента
-   *
-   * @remarks
-   * Освобождает все ресурсы:
-   * - Отписывает все subscriptions через SubscriptionManager
-   * - Отменяет pending/running валидации через cancelPendingValidation()
-   *
-   * Использует try-finally для гарантированного cleanup даже при ошибках.
-   *
-   * @example
-   * ```typescript
-   * useEffect(() => {
-   *   return () => {
-   *     field.dispose();
-   *   };
-   * }, []);
-   * ```
-   */
-  dispose() {
-    try {
-      this.disposers.dispose();
-    } finally {
-      this.cancelPendingValidation();
-    }
-  }
-}
-function O(s) {
-  const { getChildren: e, ownErrors: t, disabled: i } = s, r = h(() => t.value.length > 0 ? !1 : e().every((o) => o.disabled.value || o.valid.value)), n = h(() => !r.value), a = h(() => e().some((o) => o.pending.value)), u = h(() => e().some((o) => o.touched.value)), d = h(() => e().some((o) => o.dirty.value)), l = h(() => {
-    const o = [...t.value];
-    for (const f of e())
-      o.push(...f.errors.value);
-    return o;
-  }), c = h(() => i?.value ? "disabled" : a.value ? "pending" : n.value ? "invalid" : "valid");
-  return {
-    valid: r,
-    invalid: n,
-    pending: a,
-    touched: u,
-    dirty: d,
-    errors: l,
-    status: c
-  };
-}
-function B(s) {
-  return typeof s == "object" && s !== null && "getProxy" in s && typeof s.getProxy == "function";
-}
-const G = "$";
-function ae(s, e) {
-  let t;
-  const i = () => {
-    if (!t) {
-      const r = {};
-      e.forEach((n, a) => {
-        r[a] = n && B(n) ? n.getProxy() : n;
-      }), t = r;
-    }
-    return t;
-  };
-  return new Proxy(s, {
-    get: (r, n) => {
-      if (n === G)
-        return i();
-      if (n in r)
-        return r[n];
-      if (typeof n == "string" && e.has(n)) {
-        const a = e.get(n);
-        return a && B(a) ? a.getProxy() : a;
-      }
-    },
-    set: (r, n, a) => typeof n == "string" && e.has(n) ? !1 : (r[n] = a, !0),
-    has: (r, n) => n === G || typeof n == "string" && e.has(n) ? !0 : n in r,
-    ownKeys: (r) => {
-      const n = Reflect.ownKeys(r), a = Array.from(e.keys());
-      return [.../* @__PURE__ */ new Set([...n, ...a])];
-    },
-    getOwnPropertyDescriptor: (r, n) => typeof n == "string" && e.has(n) ? { enumerable: !0, configurable: !0 } : Reflect.getOwnPropertyDescriptor(r, n)
-  });
-}
-class oe {
-  /**
-   * @param form - Форма для отправки
-   */
-  constructor(e) {
-    this.form = e;
-  }
-  /** Внутренний сигнал состояния отправки */
-  _submitting = m(!1);
-  /** Публичный read-only сигнал состояния отправки */
-  submitting = h(() => 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: i = !1, skipTouch: r = !1 } = t || {};
-    if (r || this.form.markAsTouched(), !i && !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: i = !1, skipTouch: r = !1 } = t || {};
-    if (r || this.form.markAsTouched(), !i && !await this.form.validate())
-      return { success: !1, data: null };
-    this._submitting.value = !0;
-    try {
-      return { success: !0, data: await e(this.form.getValue()) };
-    } catch (n) {
-      return {
-        success: !1,
-        data: null,
-        error: n instanceof Error ? n : new Error(String(n))
-      };
-    } finally {
-      this._submitting.value = !1;
-    }
-  }
-}
-function le(s) {
-  const e = [];
-  for (const t of s.split(".")) {
-    const i = /^([^[\]]+)(?:\[(\d+)\])?$/.exec(t);
-    if (!i) return [];
-    e.push(i[2] !== void 0 ? { key: i[1], index: Number(i[2]) } : { key: i[1] });
-  }
-  return e;
-}
-class A extends N {
-  // ============================================================================
-  // Приватные поля
-  // ============================================================================
-  id = crypto.randomUUID();
-  /**
-   * Коллекция полей формы (упрощённый Map вместо FieldRegistry)
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  _fields = /* @__PURE__ */ new Map();
-  /**
-   * Менеджер подписок для централизованного cleanup
-   */
-  disposers = new x();
-  /**
-   * Ссылка на Proxy-инстанс
-   */
-  _proxyInstance;
-  /**
-   * Cleanup декларативной схемы поведения (createForm({ behavior })). Вызывается в dispose().
-   */
-  _behaviorCleanup;
-  /**
-   * Фабрика для создания узлов формы
-   */
-  nodeFactory = new ue();
-  // ============================================================================
-  // Приватные сигналы состояния (inline из StateManager)
-  // ============================================================================
-  /** Управление отправкой формы */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  formSubmitter;
-  /** Флаг disabled состояния */
-  _disabled = m(!1);
-  /** Form-level validation errors */
-  _formErrors = m([]);
-  /**
-   * 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, i = t != null && typeof t == "object" && ("valueSignal" in t || "value" in t), n = "form" in e && !i ? e.form : e;
-    for (const [u, d] of Object.entries(n)) {
-      const l = this.createNode(d);
-      this._fields.set(u, l);
-    }
-    this.value = h(() => {
-      const u = {};
-      return this._fields.forEach((d, l) => {
-        u[l] = d.value.value;
-      }), u;
-    });
-    const a = O({
-      getChildren: () => Array.from(this._fields.values()),
-      ownErrors: this._formErrors,
-      disabled: this._disabled
-    });
-    this.valid = a.valid, this.invalid = a.invalid, this.pending = a.pending, this.touched = a.touched, this.dirty = a.dirty, this.errors = a.errors, this.status = a.status, this.submitting = this.formSubmitter.submitting;
-  }
-  // ============================================================================
-  // Приватный метод для создания Proxy
-  // ============================================================================
-  /**
-   * Создать Proxy для типобезопасного доступа к полям
-   * @see buildFormProxy
-   */
-  buildProxy() {
-    return ae(this, this._fields);
-  }
-  // ============================================================================
-  // Реализация абстрактных методов FormNode
-  // ============================================================================
-  getValue() {
-    const e = {};
-    return this._fields.forEach((t, i) => {
-      e[i] = t.getValue();
-    }), e;
-  }
-  setValue(e, t) {
-    for (const [i, r] of Object.entries(e)) {
-      const n = this._fields.get(i);
-      if (n) {
-        const a = this._fieldSignals.get(n) ?? n.value;
-        if (R(a)) continue;
-        n.setValue(r, t);
-      }
-    }
-  }
-  patchValue(e) {
-    z(() => {
-      for (const [t, i] of Object.entries(e)) {
-        const r = this._fields.get(t);
-        if (r && i !== void 0) {
-          const n = this._fieldSignals.get(r) ?? r.value;
-          if (R(n)) continue;
-          r.setValue(i, { 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, i) => {
-      const r = e?.[i];
-      t.reset(r);
-    });
-  }
-  /**
-   * Сбросить форму к исходным значениям (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')
-   *
-   * @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 i = this;
-    for (const r of t) {
-      if (!(i instanceof A) || (i = i.getField(r.key), !i)) return;
-      if (r.index !== void 0)
-        if ("at" in i && "length" in i && typeof i.at == "function") {
-          const n = i.at(r.index);
-          if (!n) return;
-          i = n;
-        } else
-          return;
-    }
-    return i;
-  }
-  // ============================================================================
-  // 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, i) {
-    const r = this._fields.get(e), n = this._fields.get(t);
-    if (!r || !n) {
-      const d = r ? t : e;
-      throw new Error(`GroupNode.linkFields: field "${String(d)}" not found`);
-    }
-    const a = g(() => {
-      const d = r.value.value, l = i ? i(d) : d;
-      n.setValue(l, { emitEvent: !1 });
-    }), u = V(k.LinkFields);
-    return this.disposers.add(u, a);
-  }
-  /**
-   * Подписка на изменения вложенного поля по строковому пути
-   * Поддерживает вложенные пути типа "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 i = this.getFieldByPath(e);
-    if (!i)
-      throw new Error(`GroupNode.watchField: field "${e}" not found`);
-    const r = g(() => {
-      t(i.value.value);
-    }), n = V(k.WatchField);
-    return this.disposers.add(n, r);
-  }
-  /**
-   * Подписка на вложенное поле по строковому пути ("address.city").
-   * Путь нельзя выразить в типах узла → value честно `unknown`, потребитель сужает.
-   */
-  watchFieldByPath(e, t) {
-    const i = this.getFieldByPath(e);
-    if (!i)
-      throw new Error(`GroupNode.watchFieldByPath: field "${e}" not found`);
-    const r = g(() => {
-      t(i.value.value);
-    }), n = V(k.WatchField);
-    return this.disposers.add(n, r);
-  }
-  /**
-   * 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();
-    });
-  }
-}
-class j extends N {
-  // ============================================================================
-  // Приватные поля
-  // ============================================================================
-  items;
-  itemSchema;
-  initialItems;
-  /**
-   * Менеджер подписок для централизованного cleanup
-   * Использует SubscriptionManager вместо массива для управления подписками
-   */
-  disposers = new x();
-  /** Array-level validation errors (e.g., "минимум 1 элемент") */
-  _arrayErrors = m([]);
-  // ============================================================================
-  // Публичные computed signals
-  // ============================================================================
-  value;
-  valid;
-  invalid;
-  touched;
-  dirty;
-  pending;
-  errors;
-  status;
-  length;
-  // ============================================================================
-  // Конструктор
-  // ============================================================================
-  constructor(e, t = []) {
-    super(), this.itemSchema = e, this.initialItems = t, this.items = m([]);
-    for (const r of t)
-      this.push(r);
-    this.length = h(() => this.items.value.length), this.value = h(() => this.items.value.map((r) => r.value.value));
-    const i = O({
-      getChildren: () => this.items.value,
-      ownErrors: this._arrayErrors
-    });
-    this.valid = i.valid, this.invalid = i.invalid, this.pending = i.pending, this.touched = i.touched, this.dirty = i.dirty, this.errors = i.errors, this.status = i.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) {
-      w.handle(
-        new Error(
-          `ArrayNode.removeAt: index ${e} out of bounds (length: ${this.items.value.length})`
-        ),
-        "ArrayNode.removeAt",
-        E.LOG
-      );
-      return;
-    }
-    const t = this.items.value[e];
-    this.items.value = this.items.value.filter((i, r) => r !== 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) {
-      w.handle(
-        new Error(
-          `ArrayNode.insert: index ${e} out of bounds (length: ${this.items.value.length})`
-        ),
-        "ArrayNode.insert",
-        E.LOG
-      );
-      return;
-    }
-    const i = this.createItem(t), r = [...this.items.value];
-    r.splice(e, 0, i), this.items.value = r;
-  }
-  /**
-   * Переместить элемент массива с позиции `from` на позицию `to`
-   *
-   * @param from - Индекс перемещаемого элемента
-   * @param to - Целевой индекс
-   *
-   * @remarks
-   * Реордер не уничтожает элемент (dispose НЕ вызывается) — тот же инстанс под-формы
-   * переезжает на новую позицию, состояние/валидация сохраняются. Длина не меняется.
-   *
-   * @example
-   * ```typescript
-   * // Поднять элемент #2 на одну позицию вверх
-   * form.items.move(2, 1);
-   * ```
-   */
-  move(e, t) {
-    const i = this.items.value.length;
-    if (e < 0 || e >= i || t < 0 || t >= i) {
-      w.handle(
-        new Error(`ArrayNode.move: index out of bounds (from=${e}, to=${t}, length=${i})`),
-        "ArrayNode.move",
-        E.LOG
-      );
-      return;
-    }
-    if (e === t) return;
-    const r = [...this.items.value], [n] = r.splice(e, 1);
-    r.splice(t, 0, n), this.items.value = r;
-  }
-  /**
-   * Поменять местами два элемента массива
-   *
-   * @param a - Индекс первого элемента
-   * @param b - Индекс второго элемента
-   *
-   * @remarks
-   * Как и {@link move}, не уничтожает элементы — меняет только их порядок.
-   *
-   * @example
-   * ```typescript
-   * form.items.swap(0, 2);
-   * ```
-   */
-  swap(e, t) {
-    const i = this.items.value.length;
-    if (e < 0 || e >= i || t < 0 || t >= i) {
-      w.handle(
-        new Error(`ArrayNode.swap: index out of bounds (a=${e}, b=${t}, length=${i})`),
-        "ArrayNode.swap",
-        E.LOG
-      );
-      return;
-    }
-    if (e === t) return;
-    const r = [...this.items.value];
-    [r[e], r[t]] = [r[t], r[e]], this.items.value = r;
-  }
-  /**
-   * Удалить все элементы массива
-   *
-   * @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((i) => this.push(i)), t?.emitEvent !== !1 && this.validate().catch((i) => {
-      w.handle(i, "ArrayNode.setValue", E.LOG);
-    });
-  }
-  patchValue(e) {
-    e.forEach((t, i) => {
-      this.items.value[i] && t !== void 0 && this.items.value[i].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
-   */
-  forEach(e) {
-    this.items.value.forEach((t, i) => {
-      const r = t.getProxy();
-      e(r, i);
-    });
-  }
-  /**
-   * Маппинг элементов массива
-   * @param callback - Функция преобразования с типизированным GroupNode proxy
-   * @returns Новый массив результатов
-   */
-  map(e) {
-    return this.items.value.map((t, i) => {
-      const r = t.getProxy();
-      return e(r, i);
-    });
-  }
-  // ============================================================================
-  // Private методы
-  // ============================================================================
+  shouldShowIssues;
+  source;
   /**
-   * Создать новый элемент массива на основе схемы
-   * @param initialValue - Начальные значения
+   * Значение на момент построения. К нему возвращает `resetToCreation` (`resetOnDisable`), а
+   * {@link reset} — только поле над собственным сигналом, без модели за ним.
    */
-  createItem(e) {
-    if (this.isGroupSchema(this.itemSchema)) {
-      const t = new A(this.itemSchema);
-      return e && t.patchValue(e), t;
-    }
-    throw new Error(
-      "ArrayNode поддерживает только GroupNode элементы. Для массива примитивов используйте обычное поле с типом массива."
-    );
-  }
+  initialValue;
+  interaction = Ie();
+  issueState = R();
+  availability;
   /**
-   * Проверить, является ли схема групповой (объект полей)
-   * @param schema - Схема для проверки
+   * Блокировка из схемы (`disabled: true` узла — вычисляемые `total`, `fullName`). Постоянная:
+   * `enable()` контейнера её не снимает, иначе «выключить форму на время отправки → включить»
+   * разблокировало бы такие поля. Снимает её только явный `enable()` этого поля.
    */
-  isGroupSchema(e) {
-    return typeof e == "object" && e !== null && !("component" in e) && !Array.isArray(e);
+  locked;
+  pendingState = W();
+  componentState;
+  constructor(e) {
+    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 = Ne(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
+    );
+  }
+  getValue() {
+    return this.source.peek();
+  }
+  setValue(e) {
+    this.source.value = e, this.interaction.setDirty(!0);
   }
-  // ============================================================================
-  // Методы-помощники для реактивности (Фаза 1)
-  // ============================================================================
   /**
-   * Очистить все ресурсы узла
-   * Рекурсивно очищает все subscriptions и элементы массива
+   * Сбросить поле: значение, замечания, `touched` и `dirty`. Без аргумента — к точке отсчёта модели,
+   * той же, к которой возвращает `model.reset()`: значению создания модели либо последнему
+   * `captureInitial()` (загруженные данные). Поле над собственным сигналом, без модели, — к значению,
+   * с которым нода создана.
    *
-   * @example
-   * ```typescript
-   * useEffect(() => {
-   *   return () => {
-   *     arrayNode.dispose();
-   *   };
-   * }, []);
-   * ```
+   * У производного поля (цель `compute`) без аргумента сбрасывается только состояние: значением
+   * владеет поведение, а значение создания ноды снято до первого расчёта — запись вернула бы
+   * «сырое» значение, которое `compute` пересчитает лишь при смене источников.
    */
+  reset(e) {
+    e !== void 0 ? this.source.value = e : T(this.source) || (this.source.value = this.referenceValue()), this.resetState();
+  }
+  /** Точка отсчёта модели за полем; у поля без модели — значение создания. */
+  referenceValue() {
+    const e = H(this.source);
+    return e === void 0 ? this.initialValue : e.value;
+  }
+  /** Значение создания и чистое состояние, у цели `compute` тоже — для `resetOnDisable`. @internal */
+  resetToCreation() {
+    this.source.value = this.initialValue, this.resetState();
+  }
+  resetState() {
+    this.issueState.clear(), this.interaction.setTouched(!1), this.interaction.setDirty(!1);
+  }
+  markAsTouched() {
+    this.interaction.setTouched(!0);
+  }
+  markAsUntouched() {
+    this.interaction.setTouched(!1);
+  }
+  disable() {
+    this.availability.setDisabled(!0), this.issueState.clear();
+  }
+  enable() {
+    this.locked = !1, this.availability.setDisabled(!1);
+  }
+  /** Каскад от контейнера: блокировку из схемы не снимает. @internal */
+  enableFromParent() {
+    this.locked || this.availability.setDisabled(!1);
+  }
+  setIssues(e) {
+    this.issueState.set(e);
+  }
+  clearIssues() {
+    this.issueState.clear();
+  }
+  updateComponentProps(e) {
+    this.componentState.update(e);
+  }
+  /** Раннер валидации: начало (`true`) и конец (`false`) async-правил поля. @internal */
+  setPending(e) {
+    this.pendingState.mark(e);
+  }
+  /** У поля подписок нет. @internal */
   dispose() {
-    this.disposers.dispose(), this.items.value.forEach((e) => {
-      "dispose" in e && typeof e.dispose == "function" && e.dispose();
-    });
   }
-  /**
-   * Hook: вызывается после disable()
-   *
-   * Для ArrayNode: рекурсивно отключаем все элементы массива
-   *
-   * @example
-   * ```typescript
-   * // Отключить весь массив полей
-   * form.items.disable();
-   *
-   * // Все элементы становятся disabled
-   * form.items.forEach(item => {
-   *   console.log(item.status.value); // 'disabled'
-   * });
-   * ```
+}
+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: 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)
+    ])
+  };
+}
+const Ce = [
+  "value",
+  "valid",
+  "invalid",
+  "pending",
+  "disabled",
+  "touched",
+  "dirty",
+  "issues",
+  "ownIssues",
+  "getValue",
+  "setValue",
+  "reset",
+  "markAsTouched",
+  "markAsUntouched",
+  "enable",
+  "disable",
+  "setIssues",
+  "clearIssues"
+], L = new Set(Ce), N = "$";
+function Me(t) {
+  return ke(t) === "group" ? t.proxy : t;
+}
+function Te(t, e) {
+  let s;
+  const i = () => {
+    if (!s) {
+      const r = {};
+      e.forEach((o, c) => {
+        r[c] = Me(o);
+      }), s = Object.freeze(r);
+    }
+    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 === ge ? 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 De {
+  [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 - Готовые ноды детей по именам полей данных. Вид ребёнка задан нодой: по
+   *   именам и значениям группа ничего не угадывает.
    */
-  onDisable() {
-    this.items.value.forEach((e) => {
-      e.disable();
+  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;
+    });
+    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;
+  }
+  /** Лицо группы: прокси с нодами полей. Строится один раз. */
+  get proxy() {
+    return this.face ??= Te(this, this.children), this.face;
+  }
+  getValue() {
+    const e = {};
+    return this.children.forEach((s, i) => {
+      e[i] = s.getValue();
+    }), 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);
+      }
   }
   /**
-   * Hook: вызывается после enable()
-   *
-   * Для ArrayNode: рекурсивно включаем все элементы массива
-   *
-   * @example
-   * ```typescript
-   * // Включить весь массив полей
-   * form.items.enable();
-   *
-   * // Все элементы становятся enabled
-   * form.items.forEach(item => {
-   *   console.log(item.status.value); // 'valid' или 'invalid'
-   * });
-   * ```
+   * Сбросить группу: замечания группы и всех полей, `touched`, `dirty` и значения. Без аргумента —
+   * к точке отсчёта модели, той же, к которой возвращает `model.reset()` (значения создания модели
+   * либо последнего `captureInitial()`), — и форма после сброса не изменена.
+   * Цели `compute` значения не получают, как и в `setValue`: ими владеет поведение.
    */
-  onEnable() {
-    this.items.value.forEach((e) => {
-      e.enable();
+  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);
     });
   }
-}
-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();
-   *
-   * Конфиг node-level (не layout-схема M1, где `validators` уже нет).
-   * // 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 ne(e);
-    if (this.isArrayConfig(e))
-      return new j(
-        e.schema,
-        e.initialItems
-      );
-    if (this.isGroupConfig(e))
-      return new A(e);
-    throw new Error(
-      `NodeFactory: Unknown node config. Expected FieldConfig, GroupConfig, or ArrayConfig, but got: ${JSON.stringify(
-        e
-      )}`
-    );
+  /** Сброс всех полей группы к значениям создания, у целей `compute` тоже. @internal */
+  resetToCreation() {
+    this.own.clear(), this.children.forEach((e) => k(e).resetToCreation());
   }
-  /**
-   * Создать 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, ...i] = e, r = [];
-    this.isGroupConfig(t) && r.push(this.extractValues(t));
-    for (const n of i)
-      this.isGroupConfig(n) ? r.push(this.extractValues(n)) : r.push(n);
-    return new j(t, r);
+  markAsTouched() {
+    this.children.forEach((e) => e.markAsTouched());
   }
-  /**
-   * Извлечь значения из схемы (рекурсивно)
-   *
-   * ✅ НОВОЕ: Извлечено из 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 [i, r] of Object.entries(e))
-        t[i] = this.extractValues(r);
-      return t;
-    }
-    return e;
+  markAsUntouched() {
+    this.children.forEach((e) => e.markAsUntouched());
   }
-  /**
-   * Проверяет, является ли конфиг конфигурацией поля (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;
+  disable() {
+    this.availability.setDisabled(!0), this.own.clear(), this.children.forEach((e) => e.disable());
   }
-  /**
-   * Проверяет, является ли конфиг конфигурацией массива (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);
+  /** Включить группу и детей; поля с блокировкой из схемы (`disabled: true`) остаются выключенными. */
+  enable() {
+    this.availability.setDisabled(!1), this.children.forEach((e) => k(e).enableFromParent());
   }
-  /**
-   * Проверяет, является ли конфиг конфигурацией группы (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);
+  /** Каскад от контейнера — то же, что `enable()`: своей блокировки из схемы у группы нет. @internal */
+  enableFromParent() {
+    this.enable();
+  }
+  setIssues(e) {
+    this.own.set(e);
+  }
+  clearIssues() {
+    this.own.clear(), this.children.forEach((e) => e.clearIssues());
+  }
+  /** Своё ожидание async-правила на ручке группы; ожидание детей агрегат добавит сам. @internal */
+  setPending(e) {
+    this.ownPending.mark(e);
+  }
+  /** Прикрепить cleanup поведения формы (`createForm({ behavior })`). @internal */
+  attachBehaviorCleanup(e) {
+    this.behaviorCleanup = 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 N {
-  /**
-   * @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 = g(() => {
-      const r = e.length, n = [], a = [];
-      for (let l = 0; l < r; l++) {
-        const c = e.at(l);
-        if (!c) continue;
-        let o = this.cache.get(c);
-        o || (o = t(c), this.cache.set(c, o)), n.push(c), a.push(o);
+const z = /* @__PURE__ */ new WeakMap();
+let _e = 0;
+function Z(t) {
+  let e = z.get(t);
+  return e === void 0 && (e = _e++, z.set(t, e)), e;
+}
+class je {
+  /**
+   * @param control - Массив модели (`model.<путь>`).
+   * @param buildRow - Форма строки по её под-модели; инъекция снимает цикл импорта со сборкой.
+   */
+  constructor(e, s) {
+    this.control = e, this.initial = e.toArray(), this.stopSync = be(() => {
+      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 u = new Set(n), d = [];
-      for (const l of this.mountedModels) {
-        if (u.has(l)) continue;
-        const c = this.cache.get(l);
-        this.cache.delete(l), c && d.push(c);
+      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 = n, this.itemNodes.value = a, d.forEach((l) => this.disposeItemNode(l));
-    }), this.length = h(() => this.itemNodes.value.length), this.value = h(() => this.itemNodes.value.map((r) => r.value.value));
-    const i = O({
-      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 = i.valid, this.invalid = i.invalid, this.pending = i.pending, this.touched = i.touched, this.dirty = i.dirty, this.errors = i.errors, this.status = i.status;
-  }
-  itemNodes = m([]);
-  // Кэш per-item формы по идентичности фасада под-модели (фасады кэшируются в core).
-  cache = /* @__PURE__ */ new WeakMap();
-  // Фасады под-моделей, для которых сейчас смонтированы формы — «предыдущий» набор для
-  // реконсиляции в disposeSync. Выпавшие из массива элементы диспозятся и вытесняются из кэша.
-  mountedModels = [];
-  initial;
-  _arrayErrors = m([]);
-  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, i) => e(t, i));
+    return this.rows.value.map(e);
   }
   forEach(e) {
-    this.itemNodes.value.forEach((t, i) => e(t, i));
+    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` синхронизация ещё не прошла.
    */
-  dispose() {
-    this.disposeSync(), this.itemNodes.value.forEach((e) => this.disposeItemNode(e)), this.mountedModels = [];
+  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;
+    });
   }
-}
-function C(s, e, t) {
-  if (s == null || typeof s != "object" || $(s)) return;
-  if (typeof s.getProxy == "function") {
-    process.env.NODE_ENV !== "production" && console.warn(
-      "[reformer] createForm({ schema }): в схему попал узел формы (FormProxy) — он пропущен. Стройте дерево для createForm БЕЗ формы, а форму донесите до узла вторым проходом (билдер `(model, form?) => …`) либо через render-behavior `patchProps({ form })`."
-    );
-    return;
-  }
-  if (Array.isArray(s)) {
-    for (const n of s) C(n, e, t);
-    return;
-  }
-  const i = s, r = i.array;
-  if (r && typeof r.__path == "string" && typeof i.item == "function") {
-    t.set(r.__path, i.item);
-    return;
-  }
-  $(i.value) ? e.set(i.value, {
-    component: i.component,
-    componentProps: i.componentProps,
-    updateOn: i.updateOn,
-    disabled: i.disabled,
-    debounce: i.debounce
-  }) : process.env.NODE_ENV !== "production" && i.component !== void 0 && ("valueSignal" in i || i.value != null) && console.warn(
-    "[reformer] createForm({ schema }): узел с `component` не распознан как поле — `value` не является сигналом модели. Ожидается `value: model.$.<path>` (лист или массив); проверьте, что не передан `value: model.<path>` (value-прокси), группа или `valueSignal:`."
-  );
-  for (const [n, a] of Object.entries(i))
-    n !== "value" && C(a, e, t);
-}
-function q(s, e, t, i, r) {
-  const n = {};
-  for (const a of Object.keys(s)) {
-    const u = e === "" ? a : `${e}.${a}`, d = s[a];
-    if (L(d)) {
-      const l = i.has(u) ? void 0 : t.get(d);
-      if (l !== void 0) {
-        const c = d;
-        n[a] = { ...l, valueSignal: c }, r.push({ path: u, signal: c });
-      }
-      continue;
-    }
-    if (d instanceof Y) {
-      n[a] = { ...t.get(d) ?? {}, valueSignal: d }, r.push({ path: u, signal: d });
-      continue;
-    }
-    n[a] = q(
-      d,
-      u,
-      t,
-      i,
-      r
+  /** Под-модели строк по порядку — без подписки: мутацию могут вызвать из effect'а поведения. */
+  composition() {
+    return A(
+      () => Array.from({ length: this.control.length }, (e, s) => this.control.at(s))
     );
   }
-  return n;
-}
-function H(s) {
-  const { model: e, schema: t, behavior: i } = s, r = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
-  t !== void 0 && C(t, r, n);
-  const a = e.$, u = [], d = q(a, "", r, n, u), l = new A(d);
-  for (const o of Object.keys(a)) {
-    if (!L(a[o])) continue;
-    const f = n.get(o);
-    if (!f) continue;
-    const p = e[o], v = (S) => H({ model: S, schema: f(S) }), b = new de(p, v);
-    l.fields.set(o, b);
-  }
-  const c = l.getProxy();
-  for (const { path: o, signal: f } of u) {
-    const p = l.getFieldByPath(o);
-    if (p) {
-      J(f, p);
-      const v = o.lastIndexOf("."), b = v === -1 ? l : l.getFieldByPath(o.slice(0, v));
-      b instanceof A && b.registerFieldSignal(p, f);
-    }
+  /** Остановить синхронизацию и диспозить формы всех строк. @internal */
+  dispose() {
+    this.stopSync(), this.rows.peek().forEach((e) => k(e).dispose()), this.mounted = [];
   }
-  return i && l.attachBehaviorCleanup(i.__run(e, c)), c;
 }
-const ce = (s) => s != null && typeof s == "object" && "model" in s && typeof s.model?.signalAt == "function";
-function he(s) {
-  return ce(s) ? H(s) : new A(s).getProxy();
+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);
 }
-const fe = () => {
-};
-function ve(s, e) {
-  if (!e) return;
-  const t = typeof e == "function" ? { schema: e } : e, i = Object.keys(t.steps ?? {}), r = i.map((o) => t.steps?.[o]).filter((o) => o != null), n = t.schema ?? Q(
-    () => Z(...r, ...t.extras ? [t.extras] : [])
-  ), a = (o) => {
-    const f = typeof o == "number" ? i[o - 1] : o;
-    return (f != null ? t.steps?.[f] : null) ?? null;
-  }, { strategy: u, debounce: d, liveAfterSubmit: l } = t, c = P(s, n, {
-    strategy: u,
-    debounce: d,
-    liveAfterSubmit: l
-  });
-  return {
-    schema: n,
-    stepSelectors: i,
-    validate: () => c.validate(),
-    validateAll: () => c.validate(),
-    validateStep: (o) => X(s, a(o) ?? fe, { touch: !0 }),
-    createStepController: (o) => {
-      if (!u || u === "submit") return null;
-      const f = a(o);
-      return f ? P(s, f, { strategy: u, debounce: d, liveAfterSubmit: l }) : null;
-    },
-    controller: c,
-    validating: c.validating
-  };
+const b = "[@reformer/core] compileSchema", Re = /* @__PURE__ */ new Set([
+  "model",
+  "item",
+  "part",
+  "children",
+  "component",
+  "componentProps",
+  "selector",
+  "disabled",
+  "initialValue"
+]), G = {
+  value: "привязка поля — `model: model.$.<поле>`",
+  array: "привязка массива под-форм — `model: model.$.<массив>`"
+}, Ke = Object.freeze({}), te = /* @__PURE__ */ new WeakSet();
+function at(t) {
+  return t !== null && typeof t == "object" && te.has(t);
 }
-function Oe(s) {
-  if (!s.model && s.initial === void 0)
-    throw new Error("createCoreForm: provide either `initial` (to create a model) or `model`.");
-  const e = s.model ?? K(s.initial);
-  s.seed?.(e);
-  const t = he({
-    model: e,
-    ...s.schema ? { schema: s.schema(e) } : {},
-    ...s.behavior ? { behavior: s.behavior } : {}
-  }), i = ve(e, s.validation), r = { model: e, form: t, ...i ? { validation: i } : {} };
-  return s.setup?.(r), r;
+function se(t) {
+  return de(t)?.path;
 }
-function M(s) {
-  return s == null ? !1 : typeof s == "object" && "value" in s && "setValue" in s && "getValue" in s && "validate" in s;
+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 me(s) {
-  return M(s) && "validators" in s && "asyncValidators" in s && // FieldNode имеет markAsTouched метод
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  typeof s.markAsTouched == "function" && // У FieldNode нет fields или items
-  !("fields" in s) && !("items" in s);
+function We(t) {
+  return typeof t == "string" || typeof t == "number" || J(t);
 }
-function pe(s) {
-  return M(s) && "getFieldByPath" in s && "fields" in s && // GroupNode НЕ имеет items/push/removeAt (это ArrayNode/ModelArrayNode)
-  !("items" in s) && !("push" in s) && !("removeAt" in s);
+function Be(t) {
+  return t == null || typeof t == "boolean";
 }
-function ye(s) {
-  return M(s) && "items" in s && "length" in s && "push" in s && "removeAt" in s && "at" in s && // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  typeof s.push == "function" && // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  typeof s.removeAt == "function";
+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 ?? Ke,
+    source: t
+  };
 }
-function Te(s) {
-  return me(s) ? "FieldNode" : pe(s) ? "GroupNode" : ye(s) ? "ArrayNode" : M(s) ? "FormNode" : "Unknown";
+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 ge(s, e) {
-  if (s === e) return !0;
-  if (s.length !== e.length) return !1;
-  for (let t = 0; t < s.length; t++)
-    if (s[t] !== e[t]) return !1;
-  return !0;
+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 T(s, e, t, i) {
-  const r = _(null), n = _(s);
-  n.current = s;
-  const a = _(e);
-  a.current = e;
-  const u = _(t);
-  if (u.current = t, r.current === null) {
-    const c = {};
-    for (const o in s)
-      c[o] = s[o].value;
-    r.current = { ...c, __snapshot: null };
-  }
-  const d = y(
-    (c) => {
-      let o = !0;
-      return g(() => {
-        const p = n.current;
-        for (const v in p)
-          p[v].value;
-        if (o) {
-          o = !1;
-          return;
+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 (!Be(l)) {
+        if (We(l)) {
+          o === null && (o = { id: h, parts: [] }, n.push({ kind: "text", id: o.id, parts: o.parts })), o.parts.push(l);
+          continue;
         }
-        c();
-      });
-    },
-    // subscriptionKey намеренно не читается в теле — он здесь КЛЮЧ ИДЕНТИЧНОСТИ подписки (см. JSDoc
-    // параметра). Убрать его (как предлагает автофикс) значит получить subscribe, созданный один раз
-    // навсегда: подмена контрола на другой узел перестанет пересоздавать effect. Тот же приём ниже
-    // у getSnapshot.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [i]
-  ), l = y(() => {
-    const c = r.current, o = n.current, f = {};
-    for (const v in o)
-      f[v] = o[v].value;
-    let p = !1;
-    for (const v of a.current) {
-      const { key: b, useShallowArrayEqual: S } = v, D = f[b], I = c[b];
-      if (S) {
-        if (!ge(I, D)) {
-          p = !0;
-          break;
+        if (o = null, typeof l != "object" || X(l) || ve(l)) {
+          g(
+            `${b}: ребёнок ${h} — не узел и не текст (группа модели, под-модель либо значение другого типа); он пропущен. Текст — строка, число или сигнал; группу подключают узлом \`{ model: model.$.<группа>, part }\`.`
+          );
+          continue;
         }
-      } else if (I !== D) {
-        p = !0;
-        break;
+        n.push(ne(l, h, s));
       }
     }
-    if (!p && c.__snapshot)
-      return c.__snapshot;
-    for (const v in o)
-      c[v] = f[v];
-    return c.__snapshot = u.current(f), c.__snapshot;
-  }, [i]);
-  return F.useSyncExternalStore(d, l, l);
+  }
+  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 ne(t, e, s) {
+  if (s.ancestors.has(t))
+    throw new Error(`${b}: узел ${e} содержит сам себя — дерево схемы зациклено.`);
+  s.ancestors.add(t);
+  try {
+    return Ue(t, e, s);
+  } finally {
+    s.ancestors.delete(t);
+  }
 }
-function be(s) {
-  const e = {
-    value: s.value,
-    disabled: s.disabled,
-    errors: s.errors,
-    pending: s.pending,
-    valid: s.valid,
-    invalid: s.invalid,
-    touched: s.touched,
-    dirty: s.dirty,
-    shouldShowError: s.shouldShowError,
-    componentProps: s.componentProps
-  }, t = [
-    { key: "value" },
-    { key: "disabled" },
-    { key: "errors", useShallowArrayEqual: !0 },
-    { key: "pending" },
-    { key: "valid" },
-    { key: "invalid" },
-    { key: "touched" },
-    { key: "dirty" },
-    { key: "shouldShowError" },
-    { key: "componentProps" }
-  ], i = y(
-    (r) => ({
-      value: r.value,
-      pending: r.pending,
-      disabled: r.disabled,
-      errors: r.errors,
-      valid: r.valid,
-      invalid: r.invalid,
-      touched: r.touched,
-      dirty: r.dirty,
-      shouldShowError: r.shouldShowError,
-      componentProps: r.componentProps
-    }),
-    []
+function Ue(t, e, s) {
+  if (process.env.NODE_ENV !== "production")
+    for (const i of Object.keys(t)) Re.has(i) || s.unknownKeys.add(i);
+  if (typeof t.item == "function") {
+    const i = he(t.model);
+    return i ? Le(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 ? ze(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 t.model != null && g(
+    `${b}: привязка узла не распознана (узел ${e}) — он не стал полем. Ожидается \`model: model.$.<path>\` (лист или массив); проверьте, что не передан \`model: model.<path>\` (value-фасад) или группа без \`part\`.`
+  ), V(t, e, s);
+}
+function Le(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 T(e, t, i, s);
+  return i.arrays.set(e, l), l;
 }
-function Ee(s) {
-  const e = {
-    value: s.value,
-    length: s.length,
-    errors: s.errors,
-    pending: s.pending,
-    valid: s.valid,
-    invalid: s.invalid,
-    touched: s.touched,
-    dirty: s.dirty,
-    disabled: s.disabled
-  }, t = [
-    { key: "value" },
-    { key: "length" },
-    { key: "errors", useShallowArrayEqual: !0 },
-    { key: "pending" },
-    { key: "valid" },
-    { key: "invalid" },
-    { key: "touched" },
-    { key: "dirty" },
-    { key: "disabled" }
-  ], i = y(
-    (r) => ({
-      value: r.value,
-      length: r.length,
-      pending: r.pending,
-      errors: r.errors,
-      valid: r.valid,
-      invalid: r.invalid,
-      touched: r.touched,
-      dirty: r.dirty,
-      disabled: r.disabled
-    }),
-    []
+function ze(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
   );
-  return T(e, t, i, s);
+  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 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 _e() {
-  const s = y(
-    () => ({
-      value: [],
-      length: 0,
-      pending: !1,
-      errors: [],
-      valid: !0,
-      invalid: !1,
-      touched: !1,
-      dirty: !1,
-      disabled: !1
-    }),
-    []
+function qe(t, e, s) {
+  const i = /* @__PURE__ */ new Set(), n = B(t, e, s, i);
+  return i.size > 0 && re(i), n;
+}
+function re(t) {
+  const e = [...t], s = e.filter((i) => i in G).map((i) => `\`${i}\`: ${G[i]}`);
+  g(
+    `${b}: у узлов схемы есть ключи, которые сборка не читает: ${e.map((i) => `\`${i}\``).join(", ")}. Узел описывают \`model\`, \`item\`, \`part\`, \`children\`, \`component\`, \`componentProps\`, \`selector\`, \`disabled\` и \`initialValue\`; вложенные узлы читаются только из \`children\`.` + (s.length > 0 ? ` ${s.join("; ")}.` : "")
   );
-  return T({}, [], s);
 }
-function De(s) {
-  const e = s && "length" in s && "map" in s;
-  return s ? e ? Ee(s) : be(s) : _e();
+function ae(t, e, s) {
+  return qe(t, e, s?.scope ?? "#");
 }
-function Ie(s) {
-  const e = _({ value: s.value.value }), t = y(
-    (r) => {
-      let n = !0;
-      return g(() => {
-        if (s.value.value, n) {
-          n = !1;
-          return;
-        }
-        r();
-      });
-    },
-    [s]
-  ), i = y(() => {
-    const r = s.value.value;
-    return e.current.value === r ? e.current.value : (e.current.value = r, r);
-  }, [s]);
-  return F.useSyncExternalStore(t, i, i);
+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 Ve({ ...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 je(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);
+  }
+  const a = new De(s);
+  for (const [r, o] of i) a.registerLeafSignal(r, o);
+  return a;
 }
-function Re(s) {
-  const e = _({ length: s.length.value }), t = y(
-    (r) => {
-      let n = !0;
-      return g(() => {
-        if (s.length.value, n) {
-          n = !1;
-          return;
-        }
-        r();
-      });
-    },
-    [s]
-  ), i = y(() => {
-    const r = s.length.value;
-    return e.current.length === r ? e.current.length : (e.current.length = r, r);
-  }, [s]);
-  return F.useSyncExternalStore(t, i, i);
+function lt(t) {
+  const { schema: e, ...s } = t;
+  return U({
+    ...s,
+    ...e !== void 0 ? { compiled: ae(e, t.model) } : {}
+  });
 }
-function $e(s) {
-  const { model: e, schema: t, strategy: i, debounce: r, liveAfterSubmit: n } = s, a = ee(
-    () => P(e, t, { strategy: i, debounce: r, liveAfterSubmit: n }),
-    [e, t, i, r, n]
-  );
-  U(() => a.start(), [a]);
-  const u = F.useSyncExternalStore(
-    y((l) => a.validating.subscribe(l), [a]),
-    () => a.validating.peek(),
-    () => !1
-    // SSR: прогон не идёт
-  ), d = y(() => a.validate(), [a]);
-  return { submit: d, validate: d, isValidating: u };
+function xe(t) {
+  k(t).dispose();
 }
-function Be(s) {
-  const [e] = te(s), t = e.validation?.controller;
-  return U(() => t?.start(), [t]), e;
+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;
+    }
+  return r;
 }
-const Ae = ["labelTooltip"];
-function Ge(s) {
-  if (!(s == null || typeof s != "function" && typeof s != "object"))
-    return s.reformerAdapter;
+const C = "[@reformer/core] FormFlow";
+function He(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--;
+        }
+      }
+      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();
+      });
+    }
+  };
 }
-const W = (s) => s;
-function je(s, e, t = {}) {
-  const i = { ...t };
-  for (const n of Ae) delete i[n];
-  for (const n of s?.strip ?? []) delete i[n];
-  if (!s)
-    return { ...i, value: e.value, onChange: e.onChange, onBlur: e.onBlur };
-  const r = s.fromEmit ?? W;
+function Je(t) {
+  const e = w(0);
   return {
-    ...i,
-    [s.valueProp ?? "value"]: (s.toValue ?? W)(e.value),
-    [s.changeProp ?? "onChange"]: (n) => e.onChange(r(n, i)),
-    ...s.bindBlur ? s.bindBlur(e.onBlur) : { onBlur: e.onBlur }
+    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 {
+        return { status: "submitted", result: await s(n) };
+      } catch (a) {
+        return { status: "failed", error: a };
+      } finally {
+        e.value--;
+      }
+    }
   };
 }
-function we(s) {
+const M = Object.freeze({
+  status: "valid",
+  issues: /* @__PURE__ */ new Map(),
+  failures: []
+}), Y = "[@reformer/core] createForm";
+function Xe(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(`${Y}: шаг потока «${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 ? Ee(
+    () => Oe(...n, ...s.extras ? [s.extras] : [])
+  ) : void 0), r = a !== void 0 ? Pe(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(
+        `${Y}: шага «${v}» нет в потоке. ` + (m.length > 0 ? `Шаги потока: ${m.join(", ")}.` : "Поток не задан: `flow`.")
+      );
+    }
+    return i.get(v) ?? null;
+  }, f = async (v) => {
+    o.value++;
+    try {
+      return await Fe(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 ? He({ steps: [...i.keys()], validateStep: y }) : void 0, ce = Je({
+    check: r ? () => l(() => r.run({ touch: "all", submit: !0 })) : void 0,
+    values: () => t.get()
+  });
   return {
-    focus: () => s.current?.focus(),
-    blur: () => s.current?.blur(),
-    scrollIntoView: (e) => s.current?.scrollIntoView(e),
-    getElement: () => s.current
+    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) Ae(t, v);
+    }
   };
 }
-function ke(s) {
-  return typeof s == "object" && s !== null && s.nodeType === 1;
+const E = "[@reformer/core] createForm", x = (t) => t.map((e) => `"${e}"`).join(", ");
+function Qe(t, e, s) {
+  if (t === void 0) return;
+  const i = $e(e, t);
+  if (i.length > 0 && console.warn(
+    `${E}: поведение обращается к узлам схемы, которых нет в корневом дереве: ${x(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\`: ${x(a)}. Визард не свяжет их с разметкой шага.`
+    );
+  }
 }
-function We(s) {
-  const e = _(null);
-  return se(s, () => Ve(e)), e;
+function Ze(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 Ve(s) {
-  const e = s.current;
-  return e == null || ke(e) ? we(s) : e;
+function ct(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), t.model === void 0 && s.captureInitial();
+  const { tree: i, fieldWrapper: n, errorBoundary: a } = Ze(t, s), r = i !== void 0 ? ae(i, s) : void 0, o = Se(), c = o.scopeOf(s), l = Xe(s, { validation: t.validation, flow: t.flow }), h = U({
+    model: s,
+    ...r !== void 0 ? { compiled: r } : {},
+    ...t.behavior ? { behavior: t.behavior, schemaController: o } : {},
+    ...l.flow !== void 0 ? { flow: l.flow } : {}
+  });
+  process.env.NODE_ENV !== "production" && Qe(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 } : {}
+    },
+    // После `...level`: уровень снимает только себя, сборка — ещё и форму.
+    dispose() {
+      xe(h), l.dispose();
+    }
+  };
+  try {
+    t.setup?.(u);
+  } catch (f) {
+    throw u.dispose(), f;
+  }
+  return u;
 }
-const Le = Object.freeze({ runtime: "reformer-core", v: 1 });
+const ut = Object.freeze({ runtime: "reformer-core", v: 1 });
 export {
-  j as ArrayNode,
-  Le as CORE_RUNTIME_TOKEN,
-  E as ErrorStrategy,
-  Ae as FIELD_WRAPPER_ONLY_PROPS,
-  ne as FieldNode,
-  w as FormErrorHandler,
-  N as FormNode,
-  oe as FormSubmitter,
-  A as GroupNode,
-  de as ModelArrayNode,
-  ue as NodeFactory,
-  x as SubscriptionManager,
-  je as bindFieldProps,
-  ve as buildValidation,
-  Ze as computeFrom,
-  et as copyFrom,
-  Oe as createCoreForm,
-  he as createForm,
-  H as createFormFromModel,
-  K as createModel,
-  ht as disableWhen,
-  He as eachLeafSignal,
-  Ke as eachValueSignal,
-  ft as enableWhen,
-  Ge as getFieldAdapter,
-  dt as getNodeForSignal,
-  Te as getNodeType,
-  ye as isArrayNode,
-  R as isDerived,
-  me as isFieldNode,
-  M as isFormNode,
-  pe as isGroupNode,
-  Ye as isModelContainerSignal,
-  $ as isValueSignal,
-  we as makeElementFieldHandle,
-  Je as markDerived,
-  J as registerSignalNode,
-  tt as resetWhen,
-  st as revalidateWhen,
-  it as runOutsideEffect,
-  rt as safeCallback,
-  nt as safeDebouncedCallback,
-  at as syncFields,
-  ot as transformValue,
-  Qe as unmarkDerived,
-  Re as useArrayLength,
-  We as useFieldHandleRef,
-  Be as useFormBundle,
-  De as useFormControl,
-  Ie as useFormControlValue,
-  $e as useFormValidation,
-  lt as watchField
+  ut as CORE_RUNTIME_TOKEN,
+  mt as arrayOf,
+  ae as compileSchema,
+  ct as createForm,
+  He as createFormFlow,
+  lt as createFormFromModel,
+  Xe as createFormLevel,
+  ue as createModel,
+  Se as createSchemaController,
+  Pt as createSchemaScope,
+  Je as createSubmission,
+  xe as disposeForm,
+  ft as eachLeafSignal,
+  vt as eachValueSignal,
+  $t as getNodeForSignal,
+  at as isCompiledNode,
+  T as isDerived,
+  Ot as isFormArray,
+  Ft as isFormControl,
+  It as isFormGroup,
+  Nt as isFormNode,
+  X as isModelContainerSignal,
+  J as isValueSignal,
+  wt as markDerived,
+  _ as modelOf,
+  O as registerSignalNode,
+  yt as runOutsideEffect,
+  bt as safeCallback,
+  gt as safeDebouncedCallback,
+  ee as schemaSubtree,
+  $e as unknownSchemaSelectors,
+  kt as unmarkDerived
 };