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

package/dist/core/nodes/group-node.d.ts

@@ -1,21 +1,9 @@
-/**
- * GroupNode - узел группы полей формы
- *
- * Представляет группу полей (объект), где каждое поле может быть:
- * - FieldNode (простое поле)
- * - GroupNode (вложенная группа)
- * - ArrayNode (массив форм)
- *
- * Наследует от FormNode и реализует все его абстрактные методы
- *
- * @group Nodes
- */
-import type { ReadonlySignal } from '@preact/signals-core';
-import { FormNode, type SetValueOptions } from './form-node';
-import type { ValidationError, FieldStatus, ValidationSchemaFn, ValidatorRegistration, FormSchema, GroupNodeConfig, FormValue } from '../types';
-import type { GroupNodeWithControls } from '../types/group-node-proxy';
-import type { BehaviorSchemaFn } from '../behavior/types';
-import { FieldRegistry } from './group-node/field-registry';
+import { ReadonlySignal } from '@preact/signals-core';
+import { FormNode, SetValueOptions } from './form-node';
+import { ValidationError, FieldStatus, ValidationSchemaFn, ValidatorRegistration, FormSchema, GroupNodeConfig, FormValue } from '../types';
+import { FormProxy } from '../types/form-proxy';
+import { BehaviorSchemaFn } from '../behavior/types';
+import { SubmitOptions, SubmitResult } from '../utils/form-submitter';
 /**
  * GroupNode - узел для группы полей
  *
@@ -57,67 +45,47 @@ import { FieldRegistry } from './group-node/field-registry';
  * ```
  */
 export declare class GroupNode<T> extends FormNode<T> {
-    id: string;
+    id: `${string}-${string}-${string}-${string}-${string}`;
     /**
-     * Реестр полей формы
-     * Использует FieldRegistry для инкапсуляции логики управления коллекцией полей
+     * Коллекция полей формы (упрощённый Map вместо FieldRegistry)
      */
-    private fieldRegistry;
-    /**
-     * Строитель Proxy для типобезопасного доступа к полям
-     * Использует ProxyBuilder для создания Proxy с расширенной функциональностью
-     */
-    private proxyBuilder;
-    /**
-     * Менеджер состояния формы
-     * Инкапсулирует всю логику создания и управления сигналами состояния
-     * Извлечен из GroupNode для соблюдения SRP
-     */
-    private stateManager;
+    private readonly _fields;
     /**
      * Менеджер подписок для централизованного cleanup
-     * Использует SubscriptionManager вместо массива для управления подписками
      */
     private disposers;
     /**
      * Ссылка на Proxy-инстанс для использования в BehaviorContext
-     * Устанавливается в конструкторе до применения behavior schema
      */
     private _proxyInstance?;
     /**
      * Навигатор для работы с путями к полям
-     * Использует композицию вместо дублирования логики парсинга путей
      */
     private readonly pathNavigator;
     /**
      * Фабрика для создания узлов формы
-     * Использует композицию для централизованного создания FieldNode/GroupNode/ArrayNode
      */
     private readonly nodeFactory;
     /**
      * Реестр валидаторов для этой формы
-     * Использует композицию вместо глобального Singleton
-     * Обеспечивает полную изоляцию форм друг от друга
+     * Может быть инжектирован через config._validationRegistry для тестирования
      */
     private readonly validationRegistry;
     /**
      * Реестр behaviors для этой формы
-     * Использует композицию вместо глобального Singleton
-     * Обеспечивает полную изоляцию форм друг от друга
+     * Может быть инжектирован через config._behaviorRegistry для тестирования
      */
     private readonly behaviorRegistry;
     /**
      * Аппликатор для применения валидаторов к форме
-     * Извлечен из GroupNode для соблюдения SRP
-     * Использует композицию для управления процессом валидации
      */
     private readonly validationApplicator;
-    /**
-     * Аппликатор для применения behavior схемы к форме
-     * Извлечен из GroupNode для соблюдения SRP
-     * Использует композицию для управления процессом применения behaviors
-     */
-    private readonly behaviorApplicator;
+    /** Управление отправкой формы */
+    private readonly formSubmitter;
+    /** Флаг disabled состояния */
+    private readonly _disabled;
+    /** Form-level validation errors */
+    private readonly _formErrors;
     readonly value: ReadonlySignal<T>;
     readonly valid: ReadonlySignal<boolean>;
     readonly invalid: ReadonlySignal<boolean>;
@@ -135,6 +103,11 @@ export declare class GroupNode<T> extends FormNode<T> {
      * Создать GroupNode с полной конфигурацией (form, behavior, validation)
      */
     constructor(config: GroupNodeConfig<T>);
+    /**
+     * Создать Proxy для типобезопасного доступа к полям
+     * @see buildFormProxy
+     */
+    private buildProxy;
     getValue(): T;
     setValue(value: T, options?: SetValueOptions): void;
     patchValue(value: Partial<T>): void;
@@ -158,50 +131,11 @@ export declare class GroupNode<T> extends FormNode<T> {
     reset(value?: T): void;
     /**
      * Сбросить форму к исходным значениям (initialValues)
-     *
-     * @remarks
-     * Рекурсивно вызывает resetToInitial() для всех полей формы.
-     * Более явный способ сброса к начальным значениям по сравнению с reset()
-     *
-     * Полезно когда:
-     * - Пользователь нажал "Cancel" - полная отмена изменений
-     * - Форма была изменена через reset(newValues), но нужно вернуться к самому началу
-     * - Явное намерение показать "отмена всех изменений"
-     *
-     * @example
-     * ```typescript
-     * const form = new GroupNode({
-     *   email: { value: 'initial@mail.com', component: Input },
-     *   name: { value: 'John', component: Input }
-     * });
-     *
-     * form.email.setValue('changed@mail.com');
-     * form.reset({ email: 'temp@mail.com', name: 'Jane' });
-     * console.log(form.getValue()); // { email: 'temp@mail.com', name: 'Jane' }
-     *
-     * form.resetToInitial();
-     * console.log(form.getValue()); // { email: 'initial@mail.com', name: 'John' }
-     * ```
      */
     resetToInitial(): void;
     validate(): Promise<boolean>;
     /**
      * Установить form-level validation errors
-     * Используется для server-side validation или кросс-полевых ошибок
-     *
-     * @param errors - массив ошибок уровня формы
-     *
-     * @example
-     * ```typescript
-     * // Server-side validation после submit
-     * try {
-     *   await api.createUser(form.getValue());
-     * } catch (error) {
-     *   form.setErrors([
-     *     { code: 'duplicate_email', message: 'Email уже используется' }
-     *   ]);
-     * }
-     * ```
      */
     setErrors(errors: ValidationError[]): void;
     /**
@@ -210,29 +144,12 @@ export declare class GroupNode<T> extends FormNode<T> {
     clearErrors(): void;
     /**
      * Получить поле по ключу
-     *
-     * Публичный метод для доступа к полю из fieldRegistry
-     *
-     * @param key - Ключ поля
-     * @returns FormNode или undefined, если поле не найдено
-     *
-     * @example
-     * ```typescript
-     * const emailField = form.getField('email');
-     * if (emailField) {
-     *   console.log(emailField.value.value);
-     * }
-     * ```
      */
     getField<K extends keyof T>(key: K): FormNode<T[K]> | undefined;
     /**
-     * Получить Map всех полей формы
-     *
-     * Используется в FieldPathNavigator для навигации по полям
-     *
-     * @returns Map полей формы
+     * Получить Map всех полей формы (для совместимости)
      */
-    get fields(): FieldRegistry<T>;
+    get fields(): Map<keyof T, FormNode<FormValue>>;
     /**
      * Получить Proxy-инстанс для прямого доступа к полям
      *
@@ -259,52 +176,31 @@ export declare class GroupNode<T> extends FormNode<T> {
      * console.log(proxy.email.value); // Прямой доступ к полю
      * ```
      */
-    getProxy(): GroupNodeWithControls<T>;
+    getProxy(): FormProxy<T>;
     /**
      * Получить все поля формы как итератор
-     *
-     * Предоставляет доступ к внутренним полям для валидации и других операций
-     *
-     * @returns Итератор по всем полям формы
-     *
-     * @example
-     * ```typescript
-     * // Валидация всех полей
-     * await Promise.all(
-     *   Array.from(form.getAllFields()).map(field => field.validate())
-     * );
-     * ```
      */
     getAllFields(): IterableIterator<FormNode<FormValue>>;
-    /**
-     * Hook: вызывается после markAsTouched()
-     *
-     * Для GroupNode: рекурсивно помечаем все дочерние поля как touched
-     */
     protected onMarkAsTouched(): void;
-    /**
-     * Hook: вызывается после markAsUntouched()
-     *
-     * Для GroupNode: рекурсивно помечаем все дочерние поля как untouched
-     */
     protected onMarkAsUntouched(): void;
-    /**
-     * Hook: вызывается после markAsDirty()
-     *
-     * Для GroupNode: рекурсивно помечаем все дочерние поля как dirty
-     */
     protected onMarkAsDirty(): void;
+    protected onMarkAsPristine(): void;
     /**
-     * Hook: вызывается после markAsPristine()
+     * Отправить форму
      *
-     * Для GroupNode: рекурсивно помечаем все дочерние поля как pristine
+     * @param onSubmit - Callback для отправки данных
+     * @param options - Опции submit (skipValidation, skipTouch)
+     * @returns Результат от onSubmit или null если валидация не пройдена
      */
-    protected onMarkAsPristine(): void;
+    submit<R>(onSubmit: (values: T) => Promise<R> | R, options?: SubmitOptions): Promise<R | null>;
     /**
-     * Отправить форму
-     * Валидирует форму и вызывает onSubmit если форма валидна
+     * Отправить форму с расширенным результатом
+     *
+     * @param onSubmit - Callback для отправки данных
+     * @param options - Опции submit
+     * @returns Объект SubmitResult с данными, статусом и возможной ошибкой
      */
-    submit<R>(onSubmit: (values: T) => Promise<R> | R): Promise<R | null>;
+    submitWithResult<R>(onSubmit: (values: T) => Promise<R> | R, options?: SubmitOptions): Promise<SubmitResult<R>>;
     /**
      * Применить validation schema к форме
      *
@@ -314,41 +210,7 @@ export declare class GroupNode<T> extends FormNode<T> {
     applyValidationSchema(schemaFn: ValidationSchemaFn<T>): void;
     /**
      * Применить behavior schema к форме
-     *
-     * ✅ РЕФАКТОРИНГ: Делегирование BehaviorApplicator (SRP)
-     *
-     * Логика применения behavior схемы извлечена в BehaviorApplicator для:
-     * - Соблюдения Single Responsibility Principle
-     * - Уменьшения размера GroupNode (~50 строк)
-     * - Улучшения тестируемости
-     * - Консистентности с ValidationApplicator
-     *
-     * @param schemaFn Функция описания поведения формы
      * @returns Функция cleanup для отписки от всех behaviors
-     *
-     * @example
-     * ```typescript
-     * import { copyFrom, enableWhen, computeFrom } from '@/lib/forms/core/behaviors';
-     *
-     * const behaviorSchema: BehaviorSchemaFn<MyForm> = (path) => {
-     *   copyFrom(path.residenceAddress, path.registrationAddress, {
-     *     when: (form) => form.sameAsRegistration === true
-     *   });
-     *
-     *   enableWhen(path.propertyValue, (form) => form.loanType === 'mortgage');
-     *
-     *   computeFrom(
-     *     path.initialPayment,
-     *     [path.propertyValue],
-     *     (propertyValue) => propertyValue ? propertyValue * 0.2 : null
-     *   );
-     * };
-     *
-     * const cleanup = form.applyBehaviorSchema(behaviorSchema);
-     *
-     * // Cleanup при unmount
-     * useEffect(() => cleanup, []);
-     * ```
      */
     applyBehaviorSchema(schemaFn: BehaviorSchemaFn<T>): () => void;
     /**
@@ -412,29 +274,6 @@ export declare class GroupNode<T> extends FormNode<T> {
     private createNode;
     /**
      * Связывает два поля: при изменении source автоматически обновляется target
-     * Поддерживает опциональную трансформацию значения
-     *
-     * @param sourceKey - Ключ поля-источника
-     * @param targetKey - Ключ поля-цели
-     * @param transform - Опциональная функция трансформации значения
-     * @returns Функция отписки для cleanup
-     *
-     * @example
-     * ```typescript
-     * // Автоматический расчет минимального взноса от стоимости недвижимости
-     * const dispose = form.linkFields(
-     *   'propertyValue',
-     *   'initialPayment',
-     *   (propertyValue) => propertyValue ? propertyValue * 0.2 : null
-     * );
-     *
-     * // При изменении propertyValue → автоматически обновится initialPayment
-     * form.propertyValue.setValue(1000000);
-     * // initialPayment станет 200000
-     *
-     * // Cleanup
-     * useEffect(() => dispose, []);
-     * ```
      */
     linkFields<K1 extends keyof T, K2 extends keyof T>(sourceKey: K1, targetKey: K2, transform?: (value: T[K1]) => T[K2]): () => void;
     /**
@@ -467,28 +306,14 @@ export declare class GroupNode<T> extends FormNode<T> {
     watchField<K extends keyof T>(fieldPath: K extends string ? K : string, callback: (value: T[K]) => void | Promise<void>): () => void;
     /**
      * Hook: вызывается после disable()
-     *
-     * Для GroupNode: рекурсивно отключаем все дочерние поля
      */
     protected onDisable(): void;
     /**
      * Hook: вызывается после enable()
-     *
-     * Для GroupNode: рекурсивно включаем все дочерние поля
      */
     protected onEnable(): void;
     /**
      * Очистить все ресурсы узла
-     * Рекурсивно очищает все subscriptions и дочерние узлы
-     *
-     * @example
-     * ```typescript
-     * useEffect(() => {
-     *   return () => {
-     *     form.dispose();
-     *   };
-     * }, []);
-     * ```
      */
     dispose(): void;
 }

package/dist/core/types/deep-schema.d.ts

@@ -1,15 +1,5 @@
-/**
- * Типы для схемы формы (Deep Schema)
- *
- * Автоматическое определение типов схемы на основе структуры данных:
- * - `[{...}]` → массив форм
- * - `{...}` → вложенная группа
- * - `{value, component}` → конфигурация поля
- *
- * @group Types
- */
-import type { ComponentType } from 'react';
-import type { ValidatorFn, AsyncValidatorFn, FormFields, AnyFunction } from './index';
+import { ComponentType } from 'react';
+import { ValidatorFn, AsyncValidatorFn, FormFields, AnyFunction } from './index';
 /**
  * Конфигурация поля
  * @group Types

package/dist/core/types/field-path.d.ts

@@ -1,4 +1,4 @@
-import type { AnyFunction } from './index';
+import { AnyFunction } from './index';
 /**
  * FieldPath предоставляет типобезопасный доступ к путям полей формы
  *

package/dist/core/types/form-context.d.ts

@@ -1,29 +1,7 @@
-/**
- * Единый контекст для работы с формой
- *
- * Используется в:
- * - Behavior схемах (watchField, copyFrom, transformValue, etc.)
- * - Validation схемах (validate, validateAsync, validateTree)
- *
- * @example
- * ```typescript
- * // Behavior
- * watchField(path.country, (country, ctx) => {
- *   ctx.form.city.updateComponentProps({ options: cities });
- *   ctx.setFieldValue('city', null);
- * });
- *
- * // Validation
- * validate(path.email, (value, ctx) => {
- *   if (!value) return { code: 'required', message: 'Required' };
- *   const confirm = ctx.form.confirmEmail.value.value;
- *   if (value !== confirm) return { code: 'mismatch', message: 'Emails must match' };
- *   return null;
- * });
- * ```
- */
-import type { GroupNodeWithControls } from './group-node-proxy';
-import type { FieldPathNode } from './field-path';
+import { FormProxy } from './form-proxy';
+import { FieldPathNode } from './field-path';
+import { FormNode } from '../nodes/form-node';
+import { FormValue } from './index';
 /**
  * Единый контекст для работы с формой
  *
@@ -62,7 +40,7 @@ export interface FormContext<TForm> {
      * ctx.form.items.clear()
      * ```
      */
-    readonly form: GroupNodeWithControls<TForm>;
+    readonly form: FormProxy<TForm>;
     /**
      * Безопасно установить значение поля по строковому пути или FieldPath
      *
@@ -86,4 +64,26 @@ export interface FormContext<TForm> {
      * ```
      */
     setFieldValue(path: string | FieldPathNode<TForm, unknown>, value: unknown): void;
+    /**
+     * Получить поле формы по строковому пути
+     *
+     * Используется для динамического доступа к вложенным полям,
+     * особенно в модульных behavior схемах, применяемых через apply().
+     *
+     * @param path - Строковый путь к полю (например "address.city")
+     * @returns FormNode или undefined если поле не найдено
+     *
+     * @example
+     * ```typescript
+     * // В модульной behavior схеме, применяемой к вложенному полю:
+     * // apply([path.registrationAddress, path.residenceAddress], addressBehavior)
+     *
+     * watchField(path.region, (region, ctx) => {
+     *   // path.city.__path = "registrationAddress.city" или "residenceAddress.city"
+     *   const cityField = ctx.getFieldByPath(path.city.__path);
+     *   cityField?.updateComponentProps({ options: cities });
+     * });
+     * ```
+     */
+    getFieldByPath(path: string): FormNode<FormValue> | undefined;
 }

package/dist/core/types/{group-node-proxy.d.ts → form-proxy.d.ts}

@@ -1,34 +1,4 @@
-/**
- * Типы для Proxy-доступа к полям GroupNode
- *
- * Решает проблему типизации, когда GroupNode<T> использует Proxy для прямого доступа к полям.
- * TypeScript не может автоматически определить правильные типы для вложенных форм и массивов.
- *
- * @group Types
- *
- * @example
- * ```typescript
- * interface MyForm {
- *   name: string;
- *   address: {
- *     city: string;
- *   };
- *   items: Array<{ title: string }>;
- * }
- *
- * const form: GroupNodeWithControls<MyForm> = new GroupNode(schema);
- *
- * //  TypeScript знает, что это FieldNode<string>
- * form.name.setValue('John');
- *
- * //  TypeScript знает, что это GroupNode<{city: string}>
- * form.address.city.setValue('Moscow');
- *
- * //  TypeScript знает, что это ArrayNode<{title: string}>
- * form.items.push({ title: 'New Item' });
- * ```
- */
-import type { FormFields } from './index';
+import { FormFields } from './index';
 type FieldNode<_T> = any;
 type GroupNode<_T> = any;
 type ArrayNode<_T> = any;
@@ -36,9 +6,9 @@ type ArrayNode<_T> = any;
  * Мапит тип модели данных T на правильные типы узлов формы
  *
  * Рекурсивно определяет типы узлов на основе структуры данных:
- * - `T[K] extends Array<infer U>` где U - объект → `ArrayNodeWithControls<U>`
+ * - `T[K] extends Array<infer U>` где U - объект → `FormArrayProxy<U>`
  * - `T[K] extends Array<infer U>` где U - примитив → `FieldNode<T[K]>` (массив как обычное поле)
- * - `T[K] extends object` → `GroupNodeWithControls<T[K]>` (вложенная форма с типизацией)
+ * - `T[K] extends object` → `FormProxy<T[K]>` (вложенная форма с типизацией)
  * - `T[K]` примитив → `FieldNode<T[K]>` (простое поле)
  *
  * Использует NonNullable для правильной обработки опциональных полей
@@ -48,8 +18,8 @@ type ArrayNode<_T> = any;
  *
  * @template T - Тип модели данных формы
  */
-export type FormNodeControls<T> = {
-    [K in keyof T]: NonNullable<T[K]> extends Array<infer U> ? U extends FormFields ? ArrayNodeWithControls<U> : FieldNode<T[K]> : NonNullable<T[K]> extends FormFields ? NonNullable<T[K]> extends Date | File | Blob ? FieldNode<T[K]> : GroupNodeWithControls<NonNullable<T[K]>> : FieldNode<T[K]>;
+export type FormControlsProxy<T> = {
+    [K in keyof T]: NonNullable<T[K]> extends Array<infer U> ? U extends FormFields ? FormArrayProxy<U> : FieldNode<T[K]> : NonNullable<T[K]> extends FormFields ? NonNullable<T[K]> extends Date | File | Blob ? FieldNode<T[K]> : FormProxy<NonNullable<T[K]>> : FieldNode<T[K]>;
 };
 /**
  * Комбинированный тип для GroupNode с Proxy доступом к полям
@@ -72,7 +42,7 @@ export type FormNodeControls<T> = {
  *   };
  * }
  *
- * const form: GroupNodeWithControls<UserForm> = new GroupNode(schema);
+ * const form = createForm<UserForm>(schema);
  *
  * // Доступ к методам GroupNode
  * await form.validate();
@@ -84,7 +54,7 @@ export type FormNodeControls<T> = {
  * form.profile.name.setValue('John');
  * ```
  */
-export type GroupNodeWithControls<T> = GroupNode<T> & FormNodeControls<T>;
+export type FormProxy<T> = GroupNode<T> & FormControlsProxy<T>;
 /**
  * Комбинированный тип для ArrayNode с Proxy доступом к элементам
  *
@@ -102,7 +72,7 @@ export type GroupNodeWithControls<T> = GroupNode<T> & FormNodeControls<T>;
  *   completed: boolean;
  * }
  *
- * const todos: ArrayNodeWithControls<TodoItem> = new ArrayNode(schema);
+ * const todos: FormArrayProxy<TodoItem> = new ArrayNode(schema);
  *
  * // Доступ к методам ArrayNode
  * todos.push({ title: 'New todo', completed: false });
@@ -117,19 +87,19 @@ export type GroupNodeWithControls<T> = GroupNode<T> & FormNodeControls<T>;
  * });
  * ```
  */
-export type ArrayNodeWithControls<T extends FormFields> = ArrayNode<T> & {
+export type FormArrayProxy<T extends FormFields> = ArrayNode<T> & {
     /**
      * Безопасный доступ к элементу массива по индексу
      * Возвращает GroupNode с типизированными полями или undefined
      */
-    at(index: number): GroupNodeWithControls<T> | undefined;
+    at(index: number): FormProxy<T> | undefined;
     /**
      * Итерация по элементам массива с типизированными элементами
      */
-    forEach(callback: (item: GroupNodeWithControls<T>, index: number) => void): void;
+    forEach(callback: (item: FormProxy<T>, index: number) => void): void;
     /**
      * Маппинг элементов массива с типизированными элементами
      */
-    map<R>(callback: (item: GroupNodeWithControls<T>, index: number) => R): R[];
+    map<R>(callback: (item: FormProxy<T>, index: number) => R): R[];
 };
 export {};

package/dist/core/types/index.d.ts

@@ -1,3 +1,7 @@
+import { BehaviorSchemaFn } from '../behavior/types';
+import { FormSchema } from './deep-schema';
+import { ValidationSchemaFn } from './validation-schema';
+import { FormNode } from '../nodes/form-node';
 /**
  * Represents any valid form value type
  * Use this instead of 'any' for form values to maintain type safety
@@ -20,12 +24,46 @@ export type UnknownFormValue = unknown;
  * @category Validation Types
  */
 export type ValidatorFn<T = FormValue> = (value: T) => ValidationError | null;
+/**
+ * Опции для асинхронного валидатора
+ * @group Types
+ * @category Validation Types
+ */
+export interface AsyncValidatorOptions {
+    /**
+     * AbortSignal для отмены валидации
+     * Позволяет отменить асинхронную операцию при новой валидации
+     */
+    signal?: AbortSignal;
+}
 /**
  * Асинхронная функция валидации
+ *
+ * @param value - Значение для валидации
+ * @param options - Опции валидации (опционально)
+ * @returns Promise с ошибкой валидации или null если значение валидно
+ *
+ * @example
+ * ```typescript
+ * // Простой валидатор (без поддержки отмены)
+ * const emailExists: AsyncValidatorFn<string> = async (value) => {
+ *   const exists = await checkEmail(value);
+ *   return exists ? { code: 'exists', message: 'Email already exists' } : null;
+ * };
+ *
+ * // Валидатор с поддержкой отмены
+ * const emailExistsAbortable: AsyncValidatorFn<string> = async (value, options) => {
+ *   const exists = await fetch(`/api/check-email?email=${value}`, {
+ *     signal: options?.signal // Передаём signal в fetch для отмены запроса
+ *   });
+ *   return exists ? { code: 'exists', message: 'Email already exists' } : null;
+ * };
+ * ```
+ *
  * @group Types
  * @category Validation Types
  */
-export type AsyncValidatorFn<T = FormValue> = (value: T) => Promise<ValidationError | null>;
+export type AsyncValidatorFn<T = FormValue> = (value: T, options?: AsyncValidatorOptions) => Promise<ValidationError | null>;
 /**
  * Ошибка валидации
  * @group Types
@@ -64,10 +102,7 @@ export type { FieldPath, FieldPathNode } from '../types/field-path';
 export type { ContextualValidatorFn, ContextualAsyncValidatorFn, TreeValidatorFn, ConditionFn, ValidateOptions, ValidateAsyncOptions, ValidateTreeOptions, ValidationSchemaFn, ValidatorRegistration, } from './validation-schema';
 export type { FormSchema, ArrayConfig } from './deep-schema';
 export type { FormContext } from './form-context';
-export type { FormNodeControls, GroupNodeWithControls, ArrayNodeWithControls, } from './group-node-proxy';
-import type { BehaviorSchemaFn } from '../behavior/types';
-import type { FormSchema } from './deep-schema';
-import type { ValidationSchemaFn } from './validation-schema';
+export type { FormControlsProxy, FormProxy, FormArrayProxy } from './form-proxy';
 /**
  * Конфигурация GroupNode с поддержкой схем
  * Используется для создания форм с автоматическим применением behavior и validation схем
@@ -82,6 +117,18 @@ export interface GroupNodeConfig<T> {
     behavior?: BehaviorSchemaFn<T>;
     /** Схема валидации (required, email, minLength и т.д.) */
     validation?: ValidationSchemaFn<T>;
+    /**
+     * Опциональный ValidationRegistry для dependency injection
+     * Используется для тестирования с mock-реестрами
+     * @internal
+     */
+    _validationRegistry?: unknown;
+    /**
+     * Опциональный BehaviorRegistry для dependency injection
+     * Используется для тестирования с mock-реестрами
+     * @internal
+     */
+    _behaviorRegistry?: unknown;
 }
 /**
  * Тип для Record с unknown значениями
@@ -112,7 +159,6 @@ export interface ArrayNodeLike {
     at(index: number): FormNode<unknown> | undefined;
     length: unknown;
 }
-import type { FormNode } from '../nodes/form-node';
 /**
  * Конфиг с полем schema (для ArrayConfig)
  * @internal