@reformer/core 5.0.2 → 7.0.0-beta.1

package/dist/core/model/behaviors.d.ts

@@ -0,0 +1,123 @@
+import { Signal, ReadonlySignal } from '@preact/signals-core';
+/** Функция отписки от behavior-эффекта. */
+export type BehaviorCleanup = () => void;
+/**
+ * Вычисляемое поле: `target = fn(...sourceValues)` при изменении источников.
+ *
+ * @group Model
+ * @param sources Сигналы-источники (`model.$.a`, `model.$.b`).
+ * @param target Сигнал-цель (`model.$.total`).
+ * @param fn Функция вычисления значения.
+ * @param options.when Опциональное условие (получает значения источников); если false — пропуск.
+ * @returns Cleanup для отписки.
+ *
+ * @example
+ * ```typescript
+ * computeFrom([model.$.price, model.$.qty], model.$.total, (price, qty) => price * qty);
+ * ```
+ */
+export declare function computeFrom<R>(sources: ReadonlySignal<any>[], target: Signal<R>, fn: (...values: any[]) => R, options?: {
+    when?: (...values: any[]) => boolean;
+}): BehaviorCleanup;
+/**
+ * Копирование значения `source → target` (опционально по условию/с трансформом).
+ *
+ * @group Model
+ * @example
+ * ```typescript
+ * copyFrom(model.$.email, model.$.emailAdditional, { when: () => model.sameEmail });
+ * ```
+ */
+export declare function copyFrom<T>(source: ReadonlySignal<T>, target: Signal<T>, options?: {
+    when?: () => boolean;
+    transform?: (value: T) => T;
+}): BehaviorCleanup;
+/**
+ * Реакция на изменение поля: вызывает `cb(value)` при каждом изменении (по умолчанию без вызова на
+ * инициализации; `immediate: true` — вызвать сразу).
+ *
+ * @group Model
+ * @example
+ * ```typescript
+ * watchField(model.$.country, async (country) => {
+ *   model.city = '';
+ *   // ... загрузить города
+ * });
+ * ```
+ */
+export declare function watchField<T>(source: ReadonlySignal<T>, cb: (value: T) => void, options?: {
+    immediate?: boolean;
+}): BehaviorCleanup;
+/**
+ * Условное включение поля (state-операция). Резолвит ноду по сигналу-цели через реестр
+ * сигнал→нода (заполняется `createForm`) и вызывает `enable()`/`disable()` (+`reset()` при
+ * `resetOnDisable`). `condition` реактивен (читает свои сигналы модели).
+ *
+ * Запись состояния отложена через `runOutsideEffect` (микротаск) для защиты от «Cycle detected».
+ * ⚠️ Поле должно быть материализовано в форме (`createForm`) — иначе ноды в реестре нет (например,
+ * элемент массива, который строится per-item).
+ *
+ * @group Model
+ * @example
+ * ```typescript
+ * enableWhen(model.$.propertyValue, () => model.loanType === 'mortgage', { resetOnDisable: true });
+ * ```
+ */
+export declare function enableWhen(target: ReadonlySignal<unknown>, condition: () => boolean, options?: {
+    resetOnDisable?: boolean;
+}): BehaviorCleanup;
+/**
+ * Условное выключение поля (инверсия {@link enableWhen}).
+ *
+ * @group Model
+ */
+export declare function disableWhen(target: ReadonlySignal<unknown>, condition: () => boolean, options?: {
+    resetOnDisable?: boolean;
+}): BehaviorCleanup;
+/**
+ * Трансформация значения поля (идемпотентная): при изменении пишет `transformer(value)` обратно.
+ * Запись отложена (`runOutsideEffect`) во избежание «Cycle detected» (эффект читает и пишет один сигнал).
+ *
+ * @group Model
+ * @example
+ * ```typescript
+ * transformValue(model.$.promoCode, (v) => (v ?? '').toUpperCase());
+ * ```
+ */
+export declare function transformValue<T>(target: Signal<T>, transformer: (value: T) => T): BehaviorCleanup;
+/**
+ * Сброс значения поля к `resetValue` (по умолчанию `null`), когда `condition` истинно.
+ *
+ * @group Model
+ * @example
+ * ```typescript
+ * resetWhen(model.$.cardNumber, () => model.paymentType !== 'card', { resetValue: '' });
+ * ```
+ */
+export declare function resetWhen<T>(target: Signal<T>, condition: () => boolean, options?: {
+    resetValue?: T;
+}): BehaviorCleanup;
+/**
+ * Двусторонняя синхронизация двух полей (опционально с трансформом `a → b`).
+ * Сходимость обеспечивается peek-guard'ом; флаг предотвращает лишние круги.
+ *
+ * @group Model
+ * @example
+ * ```typescript
+ * syncFields(model.$.field1, model.$.field2);
+ * ```
+ */
+export declare function syncFields<T>(a: Signal<T>, b: Signal<T>, options?: {
+    transform?: (value: T) => T;
+}): BehaviorCleanup;
+/**
+ * Вызывает `revalidate()` при изменении зависимостей (не на инициализации). Под M1 валидация
+ * on-demand (`validateFormModel`), поэтому ревалидация выражается явным колбэком.
+ *
+ * @group Model
+ * @example
+ * ```typescript
+ * revalidateWhen([model.$.maxAmount], () => validateFormModel(model, schema));
+ * ```
+ */
+export declare function revalidateWhen(deps: ReadonlySignal<unknown>[], revalidate: () => void): BehaviorCleanup;

package/dist/core/model/form-model.d.ts

@@ -0,0 +1,18 @@
+import { FormModel } from './types';
+/**
+ * Создать реактивную модель данных формы (слой M1).
+ *
+ * @group Model
+ * @param initial Начальные значения (объект). Определяют форму данных и initial-снимок.
+ * @returns {@link FormModel} с value-доступом, `$`-сигналами и API (get/set/patch/isDirty/reset/signalAt).
+ *
+ * @example
+ * ```typescript
+ * const model = createModel<{ email: string; tags: string[] }>({ email: '', tags: [] });
+ * model.email = 'a@b.c';
+ * model.$.email.value;        // 'a@b.c' (сигнал)
+ * model.tags.push('x');
+ * model.get();                // { email: 'a@b.c', tags: ['x'] }
+ * ```
+ */
+export declare function createModel<T extends object>(initial: T): FormModel<T>;

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

@@ -0,0 +1,12 @@
+/**
+ * Слой данных FormModel (M1) — публичные экспорты.
+ *
+ * @group Model
+ * @module core/model
+ */
+export { createModel } from './form-model';
+export { validateModel, validateModelSync, validateFormModel } from './validate-model';
+export type { ModelValidator, ModelValidationResult } from './validate-model';
+export { computeFrom, copyFrom, watchField, enableWhen, disableWhen, transformValue, resetWhen, syncFields, revalidateWhen, } from './behaviors';
+export type { BehaviorCleanup } from './behaviors';
+export type { FormModel, ModelArray, ModelObject, ModelValue, ModelSignals, ModelApi, PathAwareSignal, } from './types';

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

@@ -0,0 +1,112 @@
+import { Signal } from '@preact/signals-core';
+/**
+ * Сигнал, который знает свой путь в модели (`'personalData.lastName'`).
+ * Используется как «ручка поля»: и привязка value в схеме, и идентичность для testId/devtools.
+ *
+ * @group Model
+ */
+export type PathAwareSignal<T> = Signal<T> & {
+    /** Путь поля в модели (dot-нотация). На элементах массива включает индекс. */
+    readonly __path: string;
+};
+/**
+ * Спец-объекты, которые трактуются как листья (не разворачиваются в под-модель).
+ * @internal
+ */
+type Opaque = Date | File | Blob;
+/**
+ * Значение поля в value-доступе модели:
+ * - массив → {@link ModelArray}
+ * - спец-объект (Date/File/Blob) → как есть
+ * - объект → вложенный value-proxy
+ * - примитив → значение
+ *
+ * @group Model
+ */
+export type ModelValue<V> = NonNullable<V> extends ReadonlyArray<infer U> ? ModelArray<U> : NonNullable<V> extends Opaque ? V : NonNullable<V> extends object ? ModelObject<NonNullable<V>> : V;
+/**
+ * value-proxy объекта: поля доступны как обычные свойства (чтение реактивно
+ * внутри `effect`/`computed`, запись — присваиванием).
+ *
+ * @group Model
+ */
+export type ModelObject<T> = {
+    [K in keyof T]: ModelValue<T[K]>;
+};
+/**
+ * Реактивный массив модели. Мутации (`push`/`removeAt`/…) меняют длину реактивно;
+ * `map`/`forEach`/`at` отдают под-модель элемента ({@link FormModel}) для объектных элементов.
+ *
+ * @group Model
+ */
+export interface ModelArray<U> {
+    /** Реактивная длина. */
+    readonly length: number;
+    /** Добавить элемент в конец (значение элемента целиком). */
+    push(item: U): void;
+    /** Вставить элемент по индексу. */
+    insertAt(index: number, item: U): void;
+    /** Удалить элемент по индексу. */
+    removeAt(index: number): void;
+    /** Переместить элемент. */
+    move(from: number, to: number): void;
+    /** Поменять местами два элемента. */
+    swap(a: number, b: number): void;
+    /** Очистить массив. */
+    clear(): void;
+    /** Под-модель элемента по индексу (для объектных элементов) или значение (для примитивных). */
+    at(index: number): U extends object ? FormModel<U> : U | undefined;
+    /** Map по элементам: объектные → {@link FormModel}, примитивные → значение. */
+    map<R>(fn: (item: U extends object ? FormModel<U> : U, index: number) => R): R[];
+    /** Итерация по элементам. */
+    forEach(fn: (item: U extends object ? FormModel<U> : U, index: number) => void): void;
+    /** Снимок массива значений (без подписки). */
+    toArray(): U[];
+    /** Индексный value-доступ. */
+    [index: number]: ModelValue<U>;
+}
+/**
+ * Дерево сигналов (escape-hatch `model.$`): листья → {@link PathAwareSignal},
+ * объекты → вложенное дерево, массивы → индексируемое дерево под-сигналов.
+ *
+ * @group Model
+ */
+export type ModelSignals<T> = {
+    [K in keyof T]: NonNullable<T[K]> extends ReadonlyArray<infer U> ? {
+        readonly length: number;
+        readonly [index: number]: ModelSignals<U & object>;
+    } : NonNullable<T[K]> extends Opaque ? PathAwareSignal<T[K]> : NonNullable<T[K]> extends object ? ModelSignals<NonNullable<T[K]>> : PathAwareSignal<T[K]>;
+};
+/**
+ * API уровня модели (доступно на корне и под-моделях элементов массива).
+ *
+ * ⚠️ Имена методов (`$`/`get`/`set`/`patch`/`isDirty`/`reset`/`signalAt`/`captureInitial`)
+ * зарезервированы: одноимённое поле формы их затеняет (редкий краевой случай).
+ *
+ * @group Model
+ */
+export interface ModelApi<T> {
+    /** Escape-hatch к сигналам: `model.$.loanType` → `PathAwareSignal<LoanType>`. */
+    readonly $: ModelSignals<T>;
+    /** Снимок значений (без подписки) — для submit. */
+    get(): T;
+    /** Массовая замена значений (load с сервера). Не меняет initial-снимок. */
+    set(value: Partial<T>): void;
+    /** Частичное слияние значений. */
+    patch(value: Partial<T>): void;
+    /** Отличаются ли текущие значения от initial-снимка (value-diff). */
+    isDirty(): boolean;
+    /** Сбросить значения к initial-снимку. */
+    reset(): void;
+    /** Зафиксировать текущие значения как новый initial-снимок («точка отсчёта»). */
+    captureInitial(): void;
+    /** Резолв строкового пути в сигнал (для error-routing/мостов). */
+    signalAt(path: string): PathAwareSignal<unknown> | undefined;
+}
+/**
+ * FormModel — value-proxy объекта `T` + {@link ModelApi}.
+ *
+ * @group Model
+ */
+export type FormModel<T> = ModelObject<T> & ModelApi<T>;
+export {};

package/dist/core/model/validate-model.d.ts

@@ -0,0 +1,46 @@
+import { ValidationError } from '../types';
+import { FormModel } from './types';
+/**
+ * Валидатор слоя данных. `value` — значение поля; `model` — ближайший scope (под-модель элемента
+ * массива или корень); `root` — корневая модель.
+ *
+ * @group Model
+ */
+export type ModelValidator<TValue = unknown, TModel = unknown, TRoot = unknown> = (value: TValue, model: TModel, root: TRoot) => ValidationError | null | Promise<ValidationError | null>;
+/**
+ * Результат валидации: ошибки по пути поля.
+ *
+ * @group Model
+ */
+export interface ModelValidationResult {
+    valid: boolean;
+    /** Ключ — путь поля (`'coBorrowers.0.relationship'`). Только поля с ошибками. */
+    errors: Record<string, ValidationError[]>;
+}
+/**
+ * Синхронная headless-валидация данных. Асинхронные валидаторы пропускаются.
+ *
+ * @group Model
+ */
+export declare function validateModelSync<T>(model: FormModel<T>, schema: unknown): ModelValidationResult;
+/**
+ * Headless-валидация данных (sync + async). Работает без UI/нод.
+ *
+ * @group Model
+ * @example
+ * ```typescript
+ * const res = await validateModel(model, schema);
+ * if (!res.valid) console.log(res.errors); // { 'email': [{ code, message }], ... }
+ * ```
+ */
+export declare function validateModel<T>(model: FormModel<T>, schema: unknown): Promise<ModelValidationResult>;
+/**
+ * In-form валидация: прогоняет {@link validateModel} и роутит ошибки в ноды формы
+ * (через реестр сигнал→нода): `node.setErrors(errors[path] ?? [])` — заодно очищает прошедшие поля
+ * И поля выключенных веток (`{ when, children }` с ложным условием). Дерево обходится ОДИН раз.
+ *
+ * @group Model
+ * @remarks Поля, не материализованные в форме (элементы массива — строятся per-item), не роутятся
+ * в родительскую форму; их ошибки доступны в возвращаемом результате по пути.
+ */
+export declare function validateFormModel<T>(model: FormModel<T>, schema: unknown): Promise<ModelValidationResult>;

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

@@ -1,6 +1,6 @@
 import { ReadonlySignal } from '@preact/signals-core';
 import { FormNode, SetValueOptions } from './form-node';
-import { FieldStatus, ValidationError, FormFields } from '../types';
+import { FieldStatus, ValidationError } from '../types';
 import { FormSchema } from '../types/deep-schema';
 import { FormProxy } from '../types/form-proxy';
 /**
@@ -20,7 +20,7 @@ import { FormProxy } from '../types/form-proxy';
  * console.log(array.length.value); // 1
  * ```
  */
-export declare class ArrayNode<T extends FormFields> extends FormNode<T[]> {
+export declare class ArrayNode<T extends object> extends FormNode<T[]> {
     private items;
     private itemSchema;
     private initialItems;
@@ -62,6 +62,38 @@ export declare class ArrayNode<T extends FormFields> extends FormNode<T[]> {
      * @param initialValue - Начальные значения для нового элемента
      */
     insert(index: number, initialValue?: Partial<T>): void;
+    /**
+     * Переместить элемент массива с позиции `from` на позицию `to`
+     *
+     * @param from - Индекс перемещаемого элемента
+     * @param to - Целевой индекс
+     *
+     * @remarks
+     * Реордер не уничтожает элемент (dispose НЕ вызывается) — тот же инстанс под-формы
+     * переезжает на новую позицию, состояние/валидация сохраняются. Длина не меняется.
+     *
+     * @example
+     * ```typescript
+     * // Поднять элемент #2 на одну позицию вверх
+     * form.items.move(2, 1);
+     * ```
+     */
+    move(from: number, to: number): void;
+    /**
+     * Поменять местами два элемента массива
+     *
+     * @param a - Индекс первого элемента
+     * @param b - Индекс второго элемента
+     *
+     * @remarks
+     * Как и {@link move}, не уничтожает элементы — меняет только их порядок.
+     *
+     * @example
+     * ```typescript
+     * form.items.swap(0, 2);
+     * ```
+     */
+    swap(a: number, b: number): void;
     /**
      * Удалить все элементы массива
      *

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

@@ -1,47 +1,29 @@
 import { ReadonlySignal } from '@preact/signals-core';
 import { FormNode, SetValueOptions } from './form-node';
-import { ValidationError, FieldStatus, ValidationSchemaFn, ValidatorRegistration, FormSchema, GroupNodeConfig, FormValue } from '../types';
+import { ValidationError, FieldStatus, FormSchema, GroupNodeConfig, FormValue } from '../types';
 import { FormProxy } from '../types/form-proxy';
-import { BehaviorSchemaFn } from '../behavior/types';
 import { SubmitOptions, SubmitResult } from '../utils/form-submitter';
 /**
  * GroupNode - узел для группы полей
  *
- * Поддерживает два API:
- * 1. Старый API (только schema) - обратная совместимость
- * 2. Новый API (config с form, behavior, validation) - автоматическое применение схем
+ * Создаётся из {@link FormSchema} (дерево field-конфигов). Обычно строится через `createForm`
+ * (M1: `createForm({ model, schema })`); валидация/behavior живут на слое модели
+ * (`validateFormModel`, `computeFrom`/`enableWhen`/…), а не на ноде.
  *
  * @group Nodes
  *
  * @example
  * ```typescript
- * // 1. Старый способ (обратная совместимость)
- * const simpleForm = new GroupNode({
- *   email: { value: '', component: Input },
- *   password: { value: '', component: Input },
- * });
- *
- * // 2. Новый способ (с behavior и validation схемами)
- * const fullForm = new GroupNode({
- *   form: {
- *     email: { value: '', component: Input },
- *     password: { value: '', component: Input },
- *   },
- *   behavior: (path) => {
- *     computeFrom(path.email, [path.email], (values) => values[0]?.trim());
- *   },
- *   validation: (path) => {
- *     required(path.email, { message: 'Email обязателен' });
- *     email(path.email);
- *     required(path.password);
- *     minLength(path.password, 8);
- *   },
+ * const form = new GroupNode({
+ *   email: { valueSignal: model.$.email, component: Input },
+ *   password: { valueSignal: model.$.password, component: Input },
  * });
  *
  * // Прямой доступ к полям через Proxy
- * fullForm.email.setValue('test@mail.com');
- * await fullForm.validate();
- * console.log(fullForm.valid.value); // true
+ * const proxy = form.getProxy();
+ * proxy.email.setValue('test@mail.com');
+ * await proxy.validate();
+ * console.log(proxy.valid.value);
  * ```
  */
 export declare class GroupNode<T> extends FormNode<T> {
@@ -55,31 +37,17 @@ export declare class GroupNode<T> extends FormNode<T> {
      */
     private disposers;
     /**
-     * Ссылка на Proxy-инстанс для использования в BehaviorContext
+     * Ссылка на Proxy-инстанс
      */
     private _proxyInstance?;
     /**
-     * Навигатор для работы с путями к полям
+     * Cleanup декларативной схемы поведения (createForm({ behavior })). Вызывается в dispose().
      */
-    private readonly pathNavigator;
+    private _behaviorCleanup?;
     /**
      * Фабрика для создания узлов формы
      */
     private readonly nodeFactory;
-    /**
-     * Реестр валидаторов для этой формы
-     * Может быть инжектирован через config._validationRegistry для тестирования
-     */
-    private readonly validationRegistry;
-    /**
-     * Реестр behaviors для этой формы
-     * Может быть инжектирован через config._behaviorRegistry для тестирования
-     */
-    private readonly behaviorRegistry;
-    /**
-     * Аппликатор для применения валидаторов к форме
-     */
-    private readonly validationApplicator;
     /** Управление отправкой формы */
     private readonly formSubmitter;
     /** Флаг disabled состояния */
@@ -201,18 +169,6 @@ export declare class GroupNode<T> extends FormNode<T> {
      * @returns Объект SubmitResult с данными, статусом и возможной ошибкой
      */
     submitWithResult<R>(onSubmit: (values: T) => Promise<R> | R, options?: SubmitOptions): Promise<SubmitResult<R>>;
-    /**
-     * Применить validation schema к форме
-     *
-     * Использует локальный реестр валидаторов (this.validationRegistry)
-     * вместо глобального Singleton для изоляции форм друг от друга.
-     */
-    applyValidationSchema(schemaFn: ValidationSchemaFn<T>): void;
-    /**
-     * Применить behavior schema к форме
-     * @returns Функция cleanup для отписки от всех behaviors
-     */
-    applyBehaviorSchema(schemaFn: BehaviorSchemaFn<T>): () => void;
     /**
      * Получить вложенное поле по пути
      *
@@ -243,19 +199,6 @@ export declare class GroupNode<T> extends FormNode<T> {
      * ```
      */
     getFieldByPath(path: string): FormNode<FormValue> | undefined;
-    /**
-     * Применить contextual валидаторы к полям
-     *
-     * ✅ РЕФАКТОРИНГ: Делегирование ValidationApplicator (SRP)
-     *
-     * Логика применения валидаторов извлечена в ValidationApplicator для:
-     * - Соблюдения Single Responsibility Principle
-     * - Уменьшения размера GroupNode (~120 строк)
-     * - Улучшения тестируемости
-     *
-     * @param validators Зарегистрированные валидаторы
-     */
-    applyContextualValidators(validators: ValidatorRegistration[]): Promise<void>;
     /**
      * Создать узел на основе конфигурации
      *
@@ -312,6 +255,11 @@ export declare class GroupNode<T> extends FormNode<T> {
      * Hook: вызывается после enable()
      */
     protected onEnable(): void;
+    /**
+     * Прикрепить cleanup декларативной схемы поведения (вызывается createForm).
+     * @internal
+     */
+    attachBehaviorCleanup(cleanup: () => void): void;
     /**
      * Очистить все ресурсы узла
      */

package/dist/core/nodes/model-array-node.d.ts

@@ -0,0 +1,71 @@
+import { Signal, ReadonlySignal } from '@preact/signals-core';
+import { FormNode } from './form-node';
+import { FieldStatus, ValidationError } from '../types';
+import { FormModel } from '../model/types';
+import { FormProxy } from '../types/form-proxy';
+/** Минимальный контракт реактивного массива модели, используемый узлом. */
+export interface ModelArrayControl<TItem extends object> {
+    readonly length: number;
+    at(index: number): FormModel<TItem> | undefined;
+    push(item: TItem): void;
+    insertAt(index: number, item: TItem): void;
+    removeAt(index: number): void;
+    move(from: number, to: number): void;
+    swap(a: number, b: number): void;
+    clear(): void;
+    toArray(): TItem[];
+}
+export declare class ModelArrayNode<T extends object> extends FormNode<T[]> {
+    private readonly control;
+    private readonly buildItem;
+    private readonly itemNodes;
+    private readonly cache;
+    private readonly initial;
+    private readonly _arrayErrors;
+    private readonly disposeSync;
+    /**
+     * Сигнал per-item форм. Публичен в т.ч. чтобы `isArrayNode` распознавал узел как массив
+     * (duck-typing проверяет наличие `items`).
+     */
+    get items(): Signal<FormProxy<T>[]>;
+    readonly value: ReadonlySignal<T[]>;
+    readonly valid: ReadonlySignal<boolean>;
+    readonly invalid: ReadonlySignal<boolean>;
+    readonly pending: ReadonlySignal<boolean>;
+    readonly touched: ReadonlySignal<boolean>;
+    readonly dirty: ReadonlySignal<boolean>;
+    readonly errors: ReadonlySignal<ValidationError[]>;
+    readonly status: ReadonlySignal<FieldStatus>;
+    readonly length: ReadonlySignal<number>;
+    /**
+     * @param control Реактивный массив модели (`model.<path>`).
+     * @param buildItem Строитель формы элемента по его под-модели (инъекция, чтобы избежать цикла
+     *   импорта с `create-form`). Обычно `(item) => createForm({ model: item, schema: itemSchema(item) })`.
+     */
+    constructor(control: ModelArrayControl<T>, buildItem: (item: FormModel<T>) => FormProxy<T>);
+    at(index: number): FormProxy<T> | undefined;
+    map<R>(fn: (item: FormProxy<T>, index: number) => R): R[];
+    forEach(fn: (item: FormProxy<T>, index: number) => void): void;
+    push(item?: Partial<T>): void;
+    insert(index: number, item?: Partial<T>): void;
+    removeAt(index: number): void;
+    /**
+     * Переместить элемент модель-массива. Делегирует мутацию массиву модели; внутренний `effect`
+     * пересоберёт `itemNodes` в новом порядке (per-item формы сохраняются по кешу идентичности).
+     */
+    move(from: number, to: number): void;
+    /** Поменять местами два элемента модель-массива (см. {@link move}). */
+    swap(a: number, b: number): void;
+    clear(): void;
+    getValue(): T[];
+    setValue(values: T[]): void;
+    patchValue(values: Partial<T[]>): void;
+    reset(values?: T[]): void;
+    resetToInitial(): void;
+    validate(): Promise<boolean>;
+    setErrors(errors: ValidationError[]): void;
+    clearErrors(): void;
+    protected onMarkAsTouched(): void;
+    /** Очистка подписки синхронизации. */
+    dispose(): void;
+}

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

@@ -1,4 +1,5 @@
 import { ComponentType } from 'react';
+import { Signal } from '@preact/signals-core';
 import { ValidatorFn, AsyncValidatorFn, FormFields, AnyFunction } from './index';
 /**
  * Конфигурация поля
@@ -6,8 +7,21 @@ import { ValidatorFn, AsyncValidatorFn, FormFields, AnyFunction } from './index'
  * @category Configuration Types
  */
 export interface FieldConfig<T> {
-    value: T | null;
-    component: ComponentType<any>;
+    /**
+     * Начальное значение-литерал (legacy-путь). Под архитектурой M1 значение приходит из
+     * {@link FieldConfig.valueSignal} (сигнал {@link FormModel}); тогда `value` не требуется.
+     */
+    value?: T | null;
+    /**
+     * Сигнал значения из {@link FormModel} (M1). Если задан — служит источником истины значения
+     * поля (нода не владеет значением, а ссылается на этот сигнал). Имеет приоритет над `value`.
+     */
+    valueSignal?: Signal<T>;
+    /**
+     * UI-компонент поля. Опционален: core-часть можно использовать без ссылки на компонент
+     * (значение/валидация работают без UI; компонент нужен только для рендеринга).
+     */
+    component?: ComponentType<any>;
     componentProps?: any;
     validators?: ValidatorFn<T>[];
     asyncValidators?: AsyncValidatorFn<T>[];

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

@@ -1,7 +1,18 @@
-import { FormFields } from './index';
-type FieldNode<_T> = any;
-type GroupNode<_T> = any;
-type ArrayNode<_T> = any;
+import { FieldNode } from '../nodes/field-node';
+import { GroupNode } from '../nodes/group-node';
+import { ArrayNode } from '../nodes/array-node';
+/**
+ * Признак «объект-группа» — обычный объект, который нужно обернуть в под-форму.
+ *
+ * Исключает массивы, спец-объекты (`Date`/`File`/`Blob`) и примитивы.
+ * Используется как дискриминатор вместо `extends FormFields` (`Record<string, FormValue>`):
+ * пользовательские модели почти всегда объявлены через `interface`, который НЕ assignable
+ * к Record-типу (у интерфейса нет неявной index signature), и потому ошибочно проваливался
+ * бы в ветку `FieldNode`. Проверка `extends object` корректно ловит и `interface`, и `type`.
+ *
+ * @internal
+ */
+type IsGroupObject<V> = V extends ReadonlyArray<unknown> ? false : V extends Date | File | Blob ? false : V extends object ? true : false;
 /**
  * Мапит тип модели данных T на правильные типы узлов формы
  *
@@ -19,7 +30,7 @@ type ArrayNode<_T> = any;
  * @template T - Тип модели данных формы
  */
 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]>;
+    [K in keyof T]-?: NonNullable<T[K]> extends ReadonlyArray<infer U> ? IsGroupObject<U> extends true ? FormArrayProxy<U & object> : FieldNode<T[K]> : IsGroupObject<NonNullable<T[K]>> extends true ? FormProxy<NonNullable<T[K]>> : FieldNode<T[K]>;
 };
 /**
  * Комбинированный тип для GroupNode с Proxy доступом к полям
@@ -87,7 +98,7 @@ export type FormProxy<T> = GroupNode<T> & FormControlsProxy<T>;
  * });
  * ```
  */
-export type FormArrayProxy<T extends FormFields> = ArrayNode<T> & {
+export type FormArrayProxy<T extends object> = ArrayNode<T> & {
     /**
      * Безопасный доступ к элементу массива по индексу
      * Возвращает GroupNode с типизированными полями или undefined