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

package/dist/form/validation/operators.d.ts

@@ -1,5 +1,5 @@
-import { FormModel, ModelArray, PathAwareSignal, ValidationError } from '../../index';
-import { AsyncRule, Rule, ValidationSchema } from './types';
+import { FormModel, ModelArray, PathAwareSignal } from '../../model/types';
+import { AsyncRule, Rule, ValidationDefinition, ValidationScope } from './types';
 /**
  * Синхронные правила поля.
  *
@@ -8,40 +8,94 @@ import { AsyncRule, Rule, ValidationSchema } from './types';
  *
  * @example
  * ```ts
- * validate(model.$.loanAmount, [required({ message: 'Сумма' }), min(50000)]);
+ * validate(model.$.loanAmount, [required({ code: 'loanAmount.required' }), min(50000)]);
  * validate(model.$.tags, [required(), maxLength(3)]); // tags: string[] — массив как значение
  * ```
  */
 export declare function validate<TField>(sig: PathAwareSignal<TField>, rules: Rule<TField>[]): void;
 /**
- * Асинхронные правила поля (зеркалит движковое разделение `validators` / `asyncValidators`).
- * Раннер дожидается их и прокидывает `AbortSignal` для отмены устаревших ответов.
+ * Асинхронные правила поля. Раннер дожидается их и прокидывает `AbortSignal` для отмены
+ * устаревших ответов.
+ *
+ * Отклонённое правило (сеть, исключение) — сбой проверки: он попадает в `failures` результата
+ * прогона, статус прогона становится `error`, а на поле ложится блокирующая ошибка `ruleFailed`
+ * (текст — из словаря локали). Отмена устаревшего прогона сбоем не считается.
  *
  * @example
  * ```ts
  * validateAsync(model.$.username, [async (v, { signal }) => {
  *   const r = await fetch(`/api/free?u=${v}`, { signal });
- *   return (await r.json()).free ? null : { code: 'taken', message: 'Занято' };
+ *   return (await r.json()).free ? null : { code: 'taken' };
  * }]);
  * ```
  */
 export declare function validateAsync<TField>(sig: PathAwareSignal<TField>, rules: AsyncRule<TField>[]): void;
 /**
  * Условная валидация: правила внутри `cb` активны, только пока `cond()` истинно; иначе их поля
- * ГАСЯТСЯ (пустой bucket → `setErrors([])`). Не трогает включение/сброс поля — это дело поведения (`enableWhen`).
+ * ГАСЯТСЯ (пустой bucket → `setIssues([])`). Не трогает включение/сброс поля — это дело поведения (`enableWhen`).
  */
 export declare function validateWhen(cond: () => boolean, cb: () => void): void;
 /**
- * Cross-field правило: `fn` получает СНАПШОТ модели текущего scope (`model.get()`) и вешает ошибку на `sig`.
- * Для элементов массива / под-моделей захватывайте нужный снапшот в замыкание (`const item = im.get()`),
- * т.к. `fn` всегда получает модель ТЕКУЩЕГО scope (корень прогона), а не под-модель.
+ * Область схемы над моделью: сама модель и `cross`, снимок которого — эта модель.
+ *
+ * @internal
+ */
+export declare function scopeOf<T>(model: FormModel<T>): ValidationScope<T>;
+/** Привязка к группе: ручка `model.$.<группа>` (тип значения — из её `peek()`). */
+interface GroupBinding<V> {
+    peek(): V;
+}
+/** Привязка к массиву под-форм: ручка `model.$.<массив>`. */
+interface ArrayBinding<U> {
+    peek(): readonly U[] | null | undefined;
+}
+/**
+ * Применить схему к КАЖДОМУ элементу массива под-форм. Схема элемента — обычная
+ * `ValidationDefinition` над типом элемента: тот же набор правил подключается и к группе через
+ * {@link apply}.
+ *
+ * У каждого элемента своя область: `cross` внутри схемы получает снапшот элемента.
+ *
+ * @example
+ * ```ts
+ * const propertyRules = defineValidation<Property>(({ model, cross }) => {
+ *   validate(model.$.type, [required()]);
+ *   cross(model.$.estimatedValue, (property) =>
+ *     property.hasEncumbrance && property.estimatedValue < 100_000 ? tooCheap : null
+ *   );
+ * });
+ *
+ * applyEach(model.$.properties, propertyRules);
+ * ```
+ */
+export declare function applyEach<U extends object>(array: ArrayBinding<U> | ModelArray<U>, schema: ValidationDefinition<U>): void;
+/**
+ * Подключить схему подформы к группе модели — одной или нескольким.
+ *
+ * Схема запускается в области группы: `model` в ней — под-модель, `cross` получает снапшот
+ * группы. Привязка — ручка `model.$.<группа>`, как у узла-подформы схемы и у `apply` поведения.
+ *
+ * @example
+ * ```ts
+ * const addressRules = defineValidation<Address>(({ model }) => {
+ *   validate(model.$.city, [required()]);
+ * });
+ *
+ * apply(model.$.registrationAddress, addressRules);
+ * validateWhen(
+ *   () => !model.sameAsRegistration,
+ *   () => apply(model.$.residenceAddress, addressRules)
+ * );
+ * ```
  */
-export declare function cross<TSnapshot>(sig: PathAwareSignal<unknown>, fn: (form: TSnapshot) => ValidationError | null): void;
+export declare function apply<V extends object | null | undefined>(group: GroupBinding<V> | GroupBinding<V>[], schema: ValidationDefinition<NonNullable<V>>): void;
 /**
- * Применить под-правила к КАЖДОМУ элементу текущего массива модели.
- * `U extends object` — элементы должны быть под-моделями (объектами); массив примитивов — одно
- * значение поля, его проверяют целиком: `validate(model.$.<массив>, [...])`.
+ * Композиция схем над ТОЙ ЖЕ моделью области — так форма собирается из схем шагов.
+ *
+ * @example
+ * ```ts
+ * const formRules = defineValidation<Form>(() => apply(loanRules, contactsRules));
+ * ```
  */
-export declare function each<U extends object>(arr: ModelArray<U>, itemFn: (item: FormModel<U>) => void): void;
-/** Композиция под-схем в текущую (над той же моделью scope). Заменяет пошаговую группировку. */
-export declare function apply<T>(...schemas: ValidationSchema<T>[]): void;
+export declare function apply<T>(...schemas: ValidationDefinition<T>[]): void;
+export {};

package/dist/form/validation/run.d.ts

@@ -1,33 +1,108 @@
-import { FormModel } from '../../index';
-import { ValidationSchema } from './types';
+import { FormModel } from '../../model/types';
+import { ValidationResult, ValidationDefinition } from './types';
 /**
  * Тонкая identity-обёртка для типизации/discoverability (как `defineFormBehavior`). Возвращает схему как есть.
  *
  * @example
  * ```ts
- * export const step1 = defineValidationSchema<LoanForm>(({ model }) => {
+ * export const step1 = defineValidation<LoanForm>(({ model }) => {
  *   validate(model.$.loanAmount, [required(), min(50000)]);
  * });
  * ```
  */
-export declare function defineValidationSchema<T>(schema: ValidationSchema<T>): ValidationSchema<T>;
+export declare function defineValidation<T>(schema: ValidationDefinition<T>): ValidationDefinition<T>;
 /**
- * Провалидировать модель ЛЮБОЙ схемой (шаг или вся форма). Открывает ambient-окно на время
- * синхронного прогона `schema`, дожидается async-правил, разносит ошибки по нодам формы и гасит
- * поля, ставшие валидными. Возвращает `true`, если нет блокирующих ошибок (`severity:'warning'` не блокирует).
+ * Отменить идущий прогон пары (model, schema): его `AbortSignal` срабатывает, ожидание async-правил
+ * размыкается, результат получает статус `cancelled` и по нодам не разносится. Контроллер живой
+ * проверки зовёт это при снятии — иначе ответ правила лёг бы на ноды уже снятой формы.
  *
- * Гашение — на пару (model, schema): `validateModel(model, step2)` и `validateModel(model, form)` не мешают
- * друг другу. Устаревший прогон (быстрый повторный вызов той же (model, schema)) отменяется через `AbortSignal`
- * и возвращает `false` (**fail-closed** — отменённому результату нельзя доверять для submit).
+ * @internal
+ */
+export declare function cancelRun(model: object, schema: object): void;
+/**
+ * Какие поля пометить тронутыми при разносе: `false` — никакие, `true` — проверенные правилами,
+ * `'all'` — проверенные, а при отказе (`invalid`, `error`) ещё и всю форму.
+ *
+ * @internal
+ */
+export type ValidationTouch = boolean | 'all';
+/** Идёт ли сейчас касание полей от имени проверки ({@link touchByValidation}). @internal */
+export declare const isTouchByValidation: () => boolean;
+/**
+ * Собрать результат проверки модели схемой — без формы и без побочных эффектов на нодах.
+ *
+ * Открывает ambient-окно на время синхронного прогона `schema`, дожидается async-правил и
+ * возвращает {@link ValidationResult}. Нод формы не трогает: ошибки по ним разносит
+ * {@link applyValidationResult}. Подходит для проверки данных без UI (сервер, тест, предпросмотр).
+ *
+ * Статус результата:
+ *  - `cancelled` — прогон устарел: пока он шёл, для той же пары (model, schema) запущен следующий;
+ *  - `error` — хотя бы одно async-правило не вернуло результат (сеть, исключение) — см. `failures`;
+ *  - `invalid` — есть блокирующие ошибки (`severity: 'warning'` не блокирует);
+ *  - `valid` — блокирующих ошибок нет.
+ *
+ * ⚠️ `schema` должна быть СТАБИЛЬНОЙ ссылкой: отмена устаревших прогонов ключится по идентичности
+ * `schema`. Держите схемы в `const` / `defineValidation`.
+ *
+ * @param model - Модель данных формы.
+ * @param schema - Схема валидации (стабильная ссылка).
+ *
+ * @example
+ * ```ts
+ * const result = await runValidation(model, formRules);
+ * if (result.status === 'error') showToast('Не удалось проверить форму, повторите попытку');
+ * else if (result.status !== 'cancelled') applyValidationResult(result, { touch: true });
+ * ```
+ */
+export declare function runValidation<T>(model: FormModel<T>, schema: ValidationDefinition<T>): Promise<ValidationResult>;
+/**
+ * Разнести собранный результат по нодам формы: поставить ошибки проверенным полям и погасить поля,
+ * которые были с ошибкой в прошлом разнесённом прогоне той же пары (model, schema), а теперь не
+ * проверялись (удалённая строка массива, выключенная ветка).
+ *
+ * Отменённый результат (`status: 'cancelled'`) не разносится: его async-часть оборвана.
+ *
+ * `options.touch`: пометить `touched` ИМЕННО поля, которые схема проверяла (не всё поддерево):
+ * поля выключенной ветки `validateWhen` и, в проверке уровня формы, выключенные поля не метятся —
+ * пользователь их не видел, и после включения их ошибка не должна быть видна с первой проверки.
+ * Замечания становятся видимыми (`shouldShowIssues`: есть замечания и `touched || dirty`) без
+ * ручного `form.markAsTouched()`; при пошаговой валидации следующий шаг не показывается
+ * «тронутым».
+ *
+ * @param result - Результат {@link runValidation}.
+ * @param options - `{ touch }` — пометить проверенные поля `touched` для показа ошибок.
+ */
+export declare function applyValidationResult(result: ValidationResult, options?: {
+    touch?: boolean;
+}): void;
+/**
+ * Прогон с разносом и полным результатом — общий движок {@link validateModel}, контроллера
+ * стратегии и прогонов шага. На время async-правил держит ноды их полей в `pending`.
+ * `skipDisabled` — проверка уровня формы: поля выключенных нод не учитываются.
+ *
+ * `touch`: `true` — пометить тронутыми проверенные поля; `'all'` — то же, а при отказе (`invalid`,
+ * `error`) ещё и всю форму: так попытка отправки раскрывает замечания полей, которых правила не
+ * касались. Отменённый результат не разносится и ничего не трогает.
+ *
+ * @internal
+ */
+export declare function runAndApply<T>(model: FormModel<T>, schema: ValidationDefinition<T>, options?: {
+    touch?: ValidationTouch;
+    skipDisabled?: boolean;
+}): Promise<ValidationResult>;
+/**
+ * Провалидировать модель ЛЮБОЙ схемой (шаг или вся форма): собрать результат и разнести ошибки по
+ * нодам формы. Возвращает `true` только для статуса `valid`: ошибки, сбой правила и отмена дают
+ * `false` (**fail-closed**). Чтобы различить их, берите {@link runValidation} либо
+ * `bundle.validate()` / `bundle.validateStep(id)` сборки формы.
  *
- * ⚠️ `schema` должна быть СТАБИЛЬНОЙ ссылкой: отмена устаревших прогонов ключится по идентичности `schema`.
- * Инлайн-стрелка (`validateModel(model, ({ model }) => …)`) каждый раз создаёт НОВЫЙ прогон без дедупликации —
- * держите схемы в `const` / `defineValidationSchema`.
+ * Гашение — на пару (model, schema): `validateModel(model, step2)` и `validateModel(model, form)`
+ * не мешают друг другу. Устаревший прогон (быстрый повторный вызов той же (model, schema))
+ * отменяется через `AbortSignal`.
  *
- * `options.touch` (§6): по завершении помечает `touched` ИМЕННО поля, которые схема проверяла
- * (не всё поддерево). Ошибки становятся видимыми (`shouldShowError = invalid && (touched||dirty)`)
- * без ручного `form.markAsTouched()`; при пошаговой валидации следующий шаг не показывается
- * «тронутым» до ввода. Валидные проверенные поля тоже метятся — это безвредно (ошибка не покажется).
+ * ⚠️ `schema` должна быть СТАБИЛЬНОЙ ссылкой: отмена устаревших прогонов ключится по идентичности
+ * `schema`. Инлайн-стрелка (`validateModel(model, ({ model }) => …)`) каждый раз создаёт НОВЫЙ
+ * прогон без дедупликации — держите схемы в `const` / `defineValidation`.
  *
  * @param model - Модель данных формы.
  * @param schema - Схема валидации (стабильная ссылка).
@@ -40,6 +115,6 @@ export declare function defineValidationSchema<T>(schema: ValidationSchema<T>):
  * const stepOk = await validateModel(model, step2Validation, { touch: true }); // + показать ошибки шага
  * ```
  */
-export declare function validateModel<T>(model: FormModel<T>, schema: ValidationSchema<T>, options?: {
+export declare function validateModel<T>(model: FormModel<T>, schema: ValidationDefinition<T>, options?: {
     touch?: boolean;
 }): Promise<boolean>;

package/dist/form/validation/strategy.d.ts

@@ -1,12 +1,13 @@
 import { ReadonlySignal } from '@preact/signals-core';
-import { FormModel } from '../../index';
-import { ValidationSchema } from './types';
+import { FormModel } from '../../model/types';
+import { ValidationResult, ValidationDefinition } from './types';
 /**
  * Когда запускается schema-валидация:
- * - `submit` (по умолчанию) — только явным вызовом `validate()` (на отправке);
- * - `blur` — при потере фокуса поля (смена `touched` любого листа);
+ * - `submit` (по умолчанию) — только явным прогоном (`validate()`, отправка);
+ * - `blur` — при потере фокуса поля (каждый уход из любого листа, и повторный тоже);
  * - `change` — на каждый ввод (с опц. `debounce`);
- * - `afterFirstSubmit` — тихо до первого `validate()`, затем live (см. `liveAfterSubmit`).
+ * - `afterFirstSubmit` — тихо до первой попытки отправки (`run({ submit: true })`), затем live
+ *   (см. `liveAfterSubmit`). Проверка без отправки (`validate()`) фазу не переключает.
  */
 export type ValidationStrategyKind = 'submit' | 'blur' | 'change' | 'afterFirstSubmit';
 export interface ValidationStrategyOptions {
@@ -17,12 +18,35 @@ export interface ValidationStrategyOptions {
     /** Режим live-фазы для `afterFirstSubmit`. Default `'change'`. */
     liveAfterSubmit?: 'change' | 'blur';
 }
+/**
+ * Опции полного прогона {@link FormValidationController.run}.
+ */
+export interface FormValidationRunOptions {
+    /**
+     * Какие поля пометить тронутыми: `true` (по умолчанию) — проверенные правилами; `'all'` — они же,
+     * а при отказе (`invalid`, `error`) ещё и вся форма.
+     */
+    touch?: true | 'all';
+    /**
+     * Прогон — попытка отправки: переводит `afterFirstSubmit` в живую фазу. Проверка без отправки
+     * (`validate()`, кнопка «Проверить») фазу не трогает.
+     */
+    submit?: boolean;
+}
 export interface FormValidationController {
     /**
-     * Полный прогон схемы с раскрытием ошибок (`touch: true`) — для submit. Также переводит
-     * `afterFirstSubmit` в live-фазу. Возвращает `false`, если есть блокирующие ошибки.
+     * Полный прогон схемы с раскрытием замечаний проверенных полей (`touch: true`). Попыткой
+     * отправки не считается: `afterFirstSubmit` остаётся в тихой фазе. Возвращает `true` только для
+     * статуса `valid`: ошибки, сбой правила и отмена дают `false`.
      */
     validate(): Promise<boolean>;
+    /**
+     * Полный прогон с полным результатом: по статусу отличают ошибки (`invalid`) от сбоя правила
+     * (`error`) и отмены (`cancelled`). Без опций — тот же прогон, что
+     * {@link FormValidationController.validate}; `{ submit: true }` — попытка отправки,
+     * `{ touch: 'all' }` — при отказе раскрыть всю форму.
+     */
+    run(options?: FormValidationRunOptions): Promise<ValidationResult>;
     /**
      * Армировать реактивные подписки стратегии. Идемпотентно. Возвращает `dispose`. НЕ звать при SSR.
      *
@@ -31,7 +55,10 @@ export interface FormValidationController {
      * после такого цикла молча оставался бы без живой валидации.
      */
     start(): () => void;
-    /** Снять подписки/таймеры. Идемпотентно; после него `start()` снова армирует стратегию. */
+    /**
+     * Снять подписки и таймеры, отменить идущий прогон (его `validate()` или `run()` получит
+     * `cancelled`). Идемпотентно; после него `start()` снова армирует стратегию.
+     */
     dispose(): void;
     /** Идёт ли прогон (submit или live) — снапшот. */
     readonly isValidating: boolean;
@@ -39,23 +66,24 @@ export interface FormValidationController {
     readonly validating: ReadonlySignal<boolean>;
 }
 /**
- * Собрать контроллер валидации формы с выбранной стратегией запуска. Переиспользует
- * {@link validateModel} как единственный движок прогона.
+ * Собрать контроллер валидации формы с выбранной стратегией запуска. Движок прогона — тот же, что у
+ * `validateModel`.
  *
  * Фабрика ЧИСТАЯ до `start()` (никаких подписок) — безопасна для SSR/headless. Реактивные триггеры
  * арминуются только в `start()` (в React — из `useEffect`).
  *
  * @typeParam T - Форма данных модели.
  * @param model - Модель данных.
- * @param schema - Схема валидации. **Стабильная ссылка** (иначе `validateModel` не отменит устаревший прогон).
+ * @param schema - Схема валидации. **Стабильная ссылка** (иначе устаревший прогон не отменится).
  * @param options - {@link ValidationStrategyOptions}.
  *
  * @example
  * ```ts
  * const ctrl = createFormValidation(model, schema, { strategy: 'afterFirstSubmit', debounce: 300 });
  * const dispose = ctrl.start();               // на клиенте
- * const ok = await ctrl.validate();           // submit → раскрыть все ошибки
+ * const ok = await ctrl.validate();           // проверка: замечания проверенных полей
+ * const sent = await ctrl.run({ touch: 'all', submit: true }); // попытка отправки: живая фаза
  * dispose();
  * ```
  */
-export declare function createFormValidation<T>(model: FormModel<T>, schema: ValidationSchema<T>, options?: ValidationStrategyOptions): FormValidationController;
+export declare function createFormValidation<T>(model: FormModel<T>, schema: ValidationDefinition<T>, options?: ValidationStrategyOptions): FormValidationController;

package/dist/form/validation/types.d.ts

@@ -1,28 +1,83 @@
-import { FormModel, ValidationError } from '../../index';
+import { FormModel, PathAwareSignal } from '../../model/types';
+import { ValidationIssue } from '../types/contracts';
 /**
- * Внутренний callable-вид правила: value-only фабрики игнорируют 2-й/3-й аргумент.
+ * Синхронное правило поля типа `TField`: получает значение, возвращает ошибку или `null`.
  *
- * @internal
- */
-export type CallableRule = (value: unknown, model: unknown, root: unknown) => ValidationError | null;
-/**
- * Синхронное правило поля типа `TField`. Проверяется ТОЛЬКО значение (`value`).
+ * Правило, написанное для более широкого типа, подходит полю с более узким: `min()` принимает
+ * `number | null | undefined` и годится и полю `number`, и полю `number | null`; `required()`
+ * принимает любое значение. Обратное — ошибка компиляции: `validate(model.$.age, [email()])`
+ * подсветится, потому что `email` ждёт строку, а поле числовое.
+ *
+ * Правило над несколькими полями — оператор `cross` области схемы: он получает снимок модели.
  *
- * Позиционные `scope`/`root` помечены `never` намеренно: так встроенные value-only фабрики
- * (`required()`/`min()`/… — они `(value, model, root) => …`) и inline-правила `(value) => …`
- * ОБА присваиваются в `Rule<TField>[]` без `any`, при этом сохраняется проверка типа поля
- * (`validate(model.$.age, [email()])` подсветится — `email` ждёт `string`, поле `number`).
- * На вызове раннер приводит правило к callable и передаёт `(value, model, model)`.
+ * @example
+ * ```ts
+ * const AMOUNT_RULES: Rule<number | null>[] = [required(), min(50000)];
+ * const notReserved: Rule<string> = (value) =>
+ *   value === 'admin' ? { code: 'reserved' } : null;
+ * ```
  */
-export type Rule<TField> = (value: TField, scope: never, root: never) => ValidationError | null;
+export type Rule<TField> = (value: TField) => ValidationIssue | null;
 /**
  * Асинхронное правило поля. Получает `AbortSignal` для отмены устаревших ответов (быстрый повторный
- * прогон той же схемы отменяет предыдущий). Сетевой сбой не должен блокировать — ловите и возвращайте `null`.
+ * прогон той же схемы отменяет предыдущий).
+ *
+ * Отклонённое правило (сеть, исключение) — это сбой проверки, а не «ошибок нет»: прогон получает
+ * статус `error`, поле — блокирующую ошибку `ruleFailed`. Если недоступность сервиса не должна
+ * мешать отправке, ловите ошибку в правиле и возвращайте `null` — это решение автора правила.
  */
 export type AsyncRule<TField> = (value: TField, ctx: {
     signal: AbortSignal;
-}) => Promise<ValidationError | null>;
-/** Схема валидации — обычная функция над (под)моделью. First-class значение (можно `apply`/тестировать/переиспользовать). */
-export type ValidationSchema<T> = (ctx: {
-    model: FormModel<T>;
-}) => void;
+}) => Promise<ValidationIssue | null>;
+/**
+ * Область схемы валидации — то, что схема получает аргументом.
+ *
+ * В корне прогона область — вся форма; в схеме, подключённой через `apply` / `applyEach`, —
+ * под-модель группы или строки массива. Поэтому правила подформы пишутся один раз и не знают, где
+ * она стоит.
+ */
+export interface ValidationScope<T> {
+    /** Модель области. Привязки правил — через её `$`: `validate(model.$.email, [...])`. */
+    readonly model: FormModel<T>;
+    /**
+     * Правило над несколькими полями: `check` получает снимок модели области (`model.get()`) и
+     * вешает ошибку на поле `handle`. Тип снимка выведен из схемы — приводить его не нужно.
+     *
+     * @example
+     * ```ts
+     * defineValidation<Loan>(({ model, cross }) => {
+     *   cross(model.$.initialPayment, (loan) =>
+     *     loan.initialPayment > loan.propertyValue ? tooHigh : null
+     *   );
+     * });
+     * ```
+     */
+    cross(handle: PathAwareSignal<unknown>, check: (snapshot: T) => ValidationIssue | null): void;
+}
+/** Схема валидации — обычная функция над областью. First-class значение (можно `apply`/тестировать/переиспользовать). */
+export type ValidationDefinition<T> = (scope: ValidationScope<T>) => void;
+/**
+ * Чем закончился прогон схемы:
+ *  - `valid` — блокирующих ошибок нет (`severity: 'warning'` не блокирует);
+ *  - `invalid` — есть блокирующие ошибки;
+ *  - `error` — хотя бы одно async-правило не вернуло результат (сеть, исключение);
+ *  - `cancelled` — прогон устарел: для той же пары (model, schema) запущен следующий.
+ *
+ * Приоритет при нескольких причинах: `cancelled` → `error` → `invalid` → `valid`.
+ */
+export type ValidationStatus = 'valid' | 'invalid' | 'cancelled' | 'error';
+/** Правило, которое не вернуло результат. */
+export interface ValidationFailure {
+    /** Ручка поля `model.$.…`, чьё правило отклонилось. */
+    readonly handle: PathAwareSignal<unknown>;
+    /** То, чем правило отклонилось (ошибка сети, исключение). */
+    readonly error: unknown;
+}
+/** Результат прогона схемы валидации — см. `runValidation`. */
+export interface ValidationResult {
+    readonly status: ValidationStatus;
+    /** Ошибки по ручке поля `model.$.…`; путь — метаданные ручки (`handle.__path`). */
+    readonly issues: ReadonlyMap<PathAwareSignal<unknown>, readonly ValidationIssue[]>;
+    /** Правила, которые не вернули результат (сеть, исключение). */
+    readonly failures: readonly ValidationFailure[];
+}

package/dist/form/validators/date-utils.d.ts

@@ -6,7 +6,14 @@
  * @module form/validators/date-utils
  */
 /**
- * Парсит значение в объект Date
+ * Парсит значение в объект Date. Строгий формат: `Date` либо строка `YYYY-MM-DD` (значение
+ * `<input type="date">`); любая другая строка — не дата. Разбор движка (`new Date(строка)`) не
+ * используется: он угадывает дату по обрывкам (`'hello 1'`, `'March 7'`), и результат зависит от
+ * движка.
+ *
+ * Строка `YYYY-MM-DD` — локальная полночь этого дня: `new Date('2024-01-01')` дал бы полночь UTC,
+ * и западнее UTC правила дат сравнивали бы предыдущий день. Несуществующая дата (`2023-02-29`)
+ * не разбирается — движок перенёс бы её на 1 марта.
  *
  * @param value - Значение для парсинга (Date, string или undefined)
  * @returns Date объект или null если парсинг не удался
@@ -20,11 +27,16 @@ export declare function getToday(): Date;
  * Нормализует дату, обнуляя время
  */
 export declare function normalizeDate(date: Date): Date;
+/** Дата рождения позже сегодняшнего дня. */
+export declare function isFutureBirth(birthDate: Date): boolean;
 /**
  * Вычисляет полный возраст (в годах) по календарным полям.
  *
  * Считаем по годам/месяцам/дням, а не делением миллисекунд на усреднённый год (365.25 дн): усреднение
  * даёт off-by-one на границе — в день N-летия накопленных реальных дней меньше `N * 365.25`, и `floor`
  * роняет возраст до `N - 1` (т.е. `minAge(18)` ошибочно отклонял 18-летнего в его день рождения).
+ *
+ * Родившийся 29 февраля в невисокосный год становится на год старше 28 февраля: срок, исчисляемый
+ * годами, истекает в последний день месяца, если соответствующего числа в нём нет (ГК РФ, ст. 192).
  */
 export declare function calculateAge(birthDate: Date): number;

package/dist/form/validators/email.d.ts

@@ -1,22 +1,23 @@
-import { Validator, ValidateOptions } from '../types/validation-schema';
+import { RuleOptions } from '../types/validation-schema';
+import { Rule } from '../validation/types';
 /**
  * Фабрика валидатора формата email.
  *
  * Проверяет по упрощённому regex `^[^\s@]+@[^\s@]+\.[^\s@]+$`. Пустые значения
  * (`''`/`null`/`undefined`) пропускаются (используйте {@link required} для обязательности).
  *
- * @param options - Опции валидатора ({@link ValidateOptions}): `message`, `params`
- * @returns Чистый валидатор {@link Validator} для строкового поля
+ * @param options - Опции валидатора ({@link RuleOptions}): `code`, `params`
+ * @returns Правило {@link Rule} для строкового поля
  *
  * @example Проверка формата email
  * ```typescript
- * import { defineValidationSchema, validate } from '@reformer/core/validation';
+ * import { defineValidation, validate } from '@reformer/core/validation';
  * import { required, email } from '@reformer/core/validators';
  *
  * // Правила живут в отдельной схеме над МОДЕЛЬЮ — layout-схема валидаторов не несёт.
- * const validation = defineValidationSchema<MyForm>(({ model }) => {
- *   validate(model.$.email, [required(), email({ message: 'Введите корректный email' })]);
+ * const validation = defineValidation<MyForm>(({ model }) => {
+ *   validate(model.$.email, [required(), email({ code: 'email.email' })]);
  * });
  * ```
  */
-export declare function email<TForm = unknown, TField extends string | null | undefined = string>(options?: ValidateOptions): Validator<TForm, TField>;
+export declare function email(options?: RuleOptions): Rule<string | null | undefined>;

package/dist/form/validators/file-type.d.ts

@@ -1,4 +1,5 @@
-import { Validator, ValidateOptions } from '../types/validation-schema';
+import { RuleOptions } from '../types/validation-schema';
+import { Rule } from '../validation/types';
 /**
  * Фабрика валидатора типа файла.
  *
@@ -12,19 +13,19 @@ import { Validator, ValidateOptions } from '../types/validation-schema';
  * пропускаются (используйте {@link required} для обязательности).
  *
  * @param accept - Accept-строка допустимых типов, например `'image/*,.pdf'`
- * @param options - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
+ * @param options - Опции валидатора ({@link RuleOptions}). В `params` ошибки автоматически
  *   попадают `accept` и `fileName` (первый нарушивший файл).
- * @returns Чистый валидатор {@link Validator} для файла или массива файлов
+ * @returns Правило {@link Rule} для файла или массива файлов
  *
  * @example Только изображения и PDF
  * ```typescript
- * import { defineValidationSchema, validate } from '@reformer/core/validation';
+ * import { defineValidation, validate } from '@reformer/core/validation';
  * import { fileType } from '@reformer/core/validators';
  *
  * // Правила живут в отдельной схеме над МОДЕЛЬЮ — layout-схема валидаторов не несёт.
- * const validation = defineValidationSchema<MyForm>(({ model }) => {
- *   validate(model.$.documents, [fileType('image/*,.pdf', { message: 'Только изображения или PDF' })]);
+ * const validation = defineValidation<MyForm>(({ model }) => {
+ *   validate(model.$.documents, [fileType('image/*,.pdf', { code: 'documents.fileType' })]);
  * });
  * ```
  */
-export declare function fileType<TForm = unknown, TField = unknown>(accept: string, options?: ValidateOptions): Validator<TForm, TField>;
+export declare function fileType(accept: string, options?: RuleOptions): Rule<unknown>;

package/dist/form/validators/file-utils.d.ts

@@ -39,7 +39,8 @@ export declare function toFileArray(value: unknown): FileLike[] | null;
 /**
  * Проверяет файл против accept-паттерна в синтаксисе нативного атрибута
  * `<input type="file" accept>`: список через запятую из расширений (`.pdf`),
- * точных MIME (`image/png`) и wildcard-категорий (`image/*`). Регистронезависимо.
+ * точных MIME (`image/png`) и wildcard-категорий (`image/*`); шаблон «любой тип» (звёздочка,
+ * слэш, звёздочка) пропускает любой файл. Регистронезависимо.
  *
  * Нужен собственный матчер, потому что `accept` у нативного input — только подсказка
  * пикеру: на drag-and-drop и на программное значение он не действует.

package/dist/form/validators/future-date.d.ts

@@ -1,22 +1,23 @@
-import { Validator, ValidateOptions } from '../types/validation-schema';
+import { RuleOptions } from '../types/validation-schema';
+import { Rule } from '../validation/types';
 /**
  * Фабрика валидатора, проверяющего что дата не в прошлом.
  *
  * Дата не должна быть раньше сегодняшнего дня (сравнение по нормализованным датам).
  * Пустые и невалидные даты пропускаются (используйте {@link required} и {@link isDate}).
  *
- * @param options - Опции валидатора ({@link ValidateOptions}): `message`, `params`
- * @returns Чистый валидатор {@link Validator} для поля даты (`string | Date`)
+ * @param options - Опции валидатора ({@link RuleOptions}): `code`, `params`
+ * @returns Правило {@link Rule} для поля даты (`string | Date`)
  *
  * @example Дата не в прошлом
  * ```typescript
- * import { defineValidationSchema, validate } from '@reformer/core/validation';
+ * import { defineValidation, validate } from '@reformer/core/validation';
  * import { required, futureDate } from '@reformer/core/validators';
  *
  * // Правила живут в отдельной схеме над МОДЕЛЬЮ — layout-схема валидаторов не несёт.
- * const validation = defineValidationSchema<MyForm>(({ model }) => {
- *   validate(model.$.appointmentDate, [required(), futureDate({ message: 'Дата записи должна быть в будущем' })]);
+ * const validation = defineValidation<MyForm>(({ model }) => {
+ *   validate(model.$.appointmentDate, [required(), futureDate({ code: 'appointmentDate.futureDate' })]);
  * });
  * ```
  */
-export declare function futureDate<TForm = unknown, TField extends string | Date | null | undefined = string | Date>(options?: ValidateOptions): Validator<TForm, TField>;
+export declare function futureDate(options?: RuleOptions): Rule<string | Date | null | undefined>;

package/dist/form/validators/index.d.ts

@@ -3,7 +3,7 @@
  *
  * Все примитивы — фабрики, возвращающие чистый `Validator<TForm, TField>`; передаются вторым
  * аргументом оператора `validate` внутри схемы валидации: `validate(model.$.age, [required(), min(18)])`.
- * В layout-схему формы правила НЕ кладутся — поля `validators` у узла нет (снято в 7.0).
+ * В layout-схему формы правила НЕ кладутся — поля `validators` у узла нет.
  *
  * Гранулярные сабпаты (`@reformer/core/validators/required` и ещё 20) собираются отдельными
  * entry для tree-shaking; этот модуль отдаёт полный набор для случаев, когда правил много.