@reformer/core 1.0.0-beta.1 → 1.0.0-beta.2

package/llms.txt

@@ -42,18 +42,18 @@
 
 ### Imports (CRITICALLY IMPORTANT)
 
-| What                                                                            | Where                       |
-| ------------------------------------------------------------------------------- | --------------------------- |
-| `createForm`, `useFormControl`, `useFormControlValue`, `validateForm`           | `@reformer/core`            |
+| What                                                                                        | Where                       |
+| ------------------------------------------------------------------------------------------- | --------------------------- |
+| `createForm`, `useFormControl`, `useFormControlValue`, `validateForm`                       | `@reformer/core`            |
 | `ValidationSchemaFn`, `BehaviorSchemaFn`, `FieldPath`, `FormProxy`, `FieldNode` | `@reformer/core`            |
-| `FormSchema`, `FieldConfig`, `ArrayNode`                                        | `@reformer/core`            |
-| `required`, `min`, `max`, `minLength`, `maxLength`, `email`                     | `@reformer/core/validators` |
-| `pattern`, `url`, `phone`, `number`, `date`                                     | `@reformer/core/validators` |
-| `validate`, `validateAsync`, `validateTree`, `applyWhen`                        | `@reformer/core/validators` |
-| `notEmpty`, `validateItems`                                                     | `@reformer/core/validators` |
-| `computeFrom`, `enableWhen`, `disableWhen`, `watchField`, `copyFrom`            | `@reformer/core/behaviors`  |
-| `resetWhen`, `revalidateWhen`, `syncFields`                                     | `@reformer/core/behaviors`  |
-| `transformValue`, `transformers`                                                | `@reformer/core/behaviors`  |
+| `FormSchema`, `FieldConfig`, `ArrayNode`                                                    | `@reformer/core`            |
+| `required`, `min`, `max`, `minLength`, `maxLength`, `email`                                 | `@reformer/core/validators` |
+| `pattern`, `url`, `phone`, `isNumber`, `integer`, `multipleOf`, `nonNegative`, `nonZero`    | `@reformer/core/validators` |
+| `validate`, `validateAsync`, `applyWhen`, `apply`                                           | `@reformer/core/validators` |
+| `notEmpty`, `validateItems`                                                                 | `@reformer/core/validators` |
+| `computeFrom`, `enableWhen`, `disableWhen`, `watchField`, `copyFrom`                        | `@reformer/core/behaviors`  |
+| `resetWhen`, `revalidateWhen`, `syncFields`                                                 | `@reformer/core/behaviors`  |
+| `transformValue`, `transformers`                                                            | `@reformer/core/behaviors`  |
 
 ### Type Values
 
@@ -63,10 +63,10 @@
 
 ### React Hooks Comparison (CRITICALLY IMPORTANT)
 
-| Hook                         | Return Type                                 | Subscribes To     | Use Case                      |
-| ---------------------------- | ------------------------------------------- | ----------------- | ----------------------------- |
-| `useFormControl(field)`      | `{ value, errors, disabled, touched, ... }` | All signals       | Full field state, form inputs |
-| `useFormControlValue(field)` | `T` (value directly)                        | Only value signal | Conditional rendering         |
+| Hook | Return Type | Subscribes To | Use Case |
+|------|-------------|---------------|----------|
+| `useFormControl(field)` | `{ value, errors, disabled, touched, ... }` | All signals | Full field state, form inputs |
+| `useFormControlValue(field)` | `T` (value directly) | Only value signal | Conditional rendering |
 
 **CRITICAL**: Do NOT destructure `useFormControlValue`! It returns `T` directly, NOT `{ value: T }`.
 
@@ -188,26 +188,39 @@ const schema: FormSchema<{ properties: PropertyItem[] }> = {
 
 ### Validators
 
-```typescript
-// Basic validators
-required(path, options?: { message?: string })
-min(path, value: number, options?: { message?: string })
-max(path, value: number, options?: { message?: string })
-minLength(path, length: number, options?: { message?: string })
-maxLength(path, length: number, options?: { message?: string })
-email(path, options?: { message?: string })
-
-// Additional validators
-pattern(path, regex: RegExp, options?: { message?: string })
-url(path, options?: { message?: string })
-phone(path, options?: { message?: string; format?: PhoneFormat })
-number(path, options?: { message?: string })
-date(path, options?: { message?: string; minAge?: number; maxAge?: number; noFuture?: boolean; noPast?: boolean })
-
-// Custom validators
-validate(path, validator: (value, ctx) => ValidationError | null)
-validateAsync(path, validator: async (value, ctx) => ValidationError | null)
-validateTree(validator: (ctx) => ValidationError | null, options?: { targetField?: string })
+Operators register validators in the schema. Validator factories return pure
+`Validator<TForm, TField>` functions of shape `(value, control, root) => ValidationError | null`.
+
+```typescript
+// Operators (register validators in schema)
+validate(path, validator: Validator<TForm, TField>, options?: { message?: string })
+validateAsync(path, validator: AsyncValidator<TForm, TField>, options?: { message?: string; debounce?: number })
+
+// Validator factories (return Validator). Pass to validate().
+required(options?: { message?: string })
+min(value: number, options?: { message?: string })
+max(value: number, options?: { message?: string })
+minLength(length: number, options?: { message?: string })
+maxLength(length: number, options?: { message?: string })
+email(options?: { message?: string })
+pattern(regex: RegExp, options?: { message?: string })
+url(options?: { message?: string; requireProtocol?: boolean })
+phone(options?: { message?: string; format?: PhoneFormat })
+// Number validator factories (atomic — compose via several validate() calls)
+isNumber(options?: { message?: string })
+integer(options?: { message?: string })
+multipleOf(divisor: number, options?: { message?: string })
+nonNegative(options?: { message?: string })       // value >= 0
+nonZero(options?: { message?: string })           // value !== 0
+date(options?: { message?: string; minAge?: number; maxAge?: number; noFuture?: boolean; noPast?: boolean })
+notEmpty(options?: { message?: string })
+
+// Usage: pass a factory result to validate()
+validate(path.email, required());
+validate(path.age, min(18));
+validate(path.amount, integer());
+validate(path.amount, min(0));
+validate(path.amount, max(1000));
 
 // Conditional validation (3 arguments!)
 applyWhen(fieldPath, condition: (fieldValue) => boolean, validatorsFn: (path) => void)
@@ -220,8 +233,8 @@ applyWhen(
   path.loanType,                    // 1st: field to watch
   (type) => type === 'mortgage',    // 2nd: condition on field value
   (p) => {                          // 3rd: validators to apply
-    required(p.propertyValue);
-    min(p.propertyValue, 100000);
+    validate(p.propertyValue, required());
+    validate(p.propertyValue, min(100000));
   }
 );
 
@@ -230,8 +243,8 @@ applyWhen(
   path.address.country,
   (country) => country === 'US',
   (p) => {
-    required(p.address.state);
-    pattern(p.address.zip, /^\d{5}(-\d{4})?$/);
+    validate(p.address.state, required());
+    validate(p.address.zip, pattern(/^\d{5}(-\d{4})?$/));
   }
 );
 
@@ -240,19 +253,18 @@ applyWhen(
   path.hasInsurance,
   (has) => has === true,
   (p) => {
-    required(p.insuranceCompany);
-    required(p.policyNumber);
+    validate(p.insuranceCompany, required());
+    validate(p.policyNumber, required());
   }
 );
 
 // WRONG - only 2 arguments (React Hook Form pattern)
 applyWhen(
   (form) => form.loanType === 'mortgage',  // WRONG!
-  () => { required(path.propertyValue); }
+  () => { validate(path.propertyValue, required()); }
 );
 
-// Array validators
-notEmpty(path, options?: { message?: string })
+// Array item schema operator
 validateItems(arrayPath, itemValidatorsFn: (itemPath) => void)
 ```
 
@@ -426,26 +438,29 @@ const { value } = useFormControl(form.field as FieldNode<ExpectedType>);
 
 ### Validation Priority (IMPORTANT)
 
-**Always prefer built-in validators over custom ones:**
+**Operators register validators; built-in factories return validators. Pass factories to `validate()`.**
+
+Operators: `validate`, `validateAsync`, `applyWhen`, `apply`, `validateItems`.
+Factories (return `Validator<TForm, TField>`): `required`, `email`, `min`, `max`, `minLength`, `maxLength`,
+`pattern`, `url`, `phone`, `number`, `date`, `notEmpty`.
 
 ```typescript
-// 1. BEST: Use built-in validators when available
-required(path.email);
-email(path.email);
-min(path.age, 18);
-minLength(path.password, 8);
-pattern(path.phone, /^\+7\d{10}$/);
+// 1. BEST: Pass built-in factories to validate()
+validate(path.email, required());
+validate(path.email, email());
+validate(path.age, min(18));
+validate(path.password, minLength(8));
+validate(path.phone, pattern(/^\+7\d{10}$/));
 
-// 2. GOOD: Use validate() only when no built-in validator exists
-validate(path.customField, (value, ctx) => {
-  // Custom logic that can't be expressed with built-in validators
+// 2. GOOD: Custom validator when no factory fits. Signature: (value, control, root).
+validate(path.customField, (value, control, root) => {
   if (customCondition(value)) {
     return { code: 'custom', message: 'Custom error' };
   }
   return null;
 });
 
-// 3. WRONG: Don't recreate built-in validators
+// 3. WRONG: Don't recreate built-in validators inline
 validate(path.email, (value) => {
   if (!value) return { code: 'required', message: 'Required' }; // Use required() instead!
   if (!value.includes('@')) return { code: 'email', message: 'Invalid' }; // Use email() instead!
@@ -532,6 +547,68 @@ const behavior: BehaviorSchemaFn<LoanForm> = (path) => {
 
 Reference patterns: `complex-multy-step-form/schemas/credit-application-behavior.ts`.
 
+### Extracting Nested Rules
+
+When the body of `applyWhen` / `validate` grows beyond a few lines,
+extract it to a **named top-level function** typed with one of the public types from
+`@reformer/core`:
+
+- `ValidationSchemaFn<TForm>` — sub-schema passed to `applyWhen` or `apply`.
+- `Validator<TForm, TField>` / `AsyncValidator<TForm, TField>` — field validator passed to `validate` / `validateAsync`. Cross-field правила пишутся в той же сигнатуре — `(value, control, root) => …` — и навешиваются на конкретное поле-носитель ошибки.
+
+This keeps the schema body flat (reads like a table of contents) and surfaces the
+**intent** of each rule via a meaningful name.
+
+```typescript
+import type { ValidationSchemaFn, Validator } from '@reformer/core';
+
+// 1. Cross-field rule — extracted Validator (reads other fields via `root`)
+const initialPaymentVsPropertyValue: Validator<CreditApplicationForm, unknown> = (
+  _value,
+  _control,
+  root
+) => {
+  const form = root.getValue();
+  if (form.initialPayment && form.propertyValue && form.initialPayment > form.propertyValue) {
+    return { code: 'initialPaymentTooHigh', message: 'Взнос не может превышать стоимость' };
+  }
+  return null;
+};
+
+// 2. Custom field validator — extracted Validator
+const validateAdultAge: Validator<CreditApplicationForm, string | undefined> = (value) => {
+  if (!value) return null;
+  const age = new Date().getFullYear() - new Date(value).getFullYear();
+  if (age < 18) return { code: 'tooYoung', message: 'Минимум 18 лет' };
+  return null;
+};
+
+// 3. Nested schema for applyWhen — extracted ValidationSchemaFn
+const mortgageFieldsRules: ValidationSchemaFn<CreditApplicationForm> = (path) => {
+  validate(path.propertyValue, required());
+  validate(path.propertyValue, min(1000000));
+  validate(path.initialPayment, required());
+  validate(path.initialPayment, initialPaymentVsPropertyValue);
+};
+
+// 4. Main schema — flat, reads as a table of contents
+export const basicInfoValidation: ValidationSchemaFn<CreditApplicationForm> = (path) => {
+  validate(path.loanType, required());
+  validate(path.personalData.birthDate, validateAdultAge);
+  applyWhen(path.loanType, (type) => type === 'mortgage', mortgageFieldsRules);
+};
+```
+
+**Naming convention** (camelCase, semantic — not echoing the operator name):
+
+- `applyWhen` sub-schema → describes the conditional branch: `mortgageFieldsRules`, `employedFieldsRules`.
+- Cross-field `Validator` → describes the invariant: `initialPaymentVsPropertyValue`, `paymentToIncomeUnderHalf`.
+- Field-level `Validator` → describes the check: `validateAdultAge`, `validatePasswordsMatch`.
+
+**When to extract.** Inline lambdas are fine for short one-liners
+(`applyWhen(path.x, (v) => v === 'mortgage', mortgageFieldsRules)` — the condition stays inline).
+Extract whenever the body spans more than ~3 lines or contains nested rules.
+
 ## 6. 4. COMMON MISTAKES
 
 ### TSC overload-resolution error: `'form' does not exist in FormSchema<T>`
@@ -1274,19 +1351,32 @@ enableWhen(path.vehicle.vin, (form) => form.insuranceType === 'casco', { resetOn
 
 See `22-cycle-detection.md` for complete pattern.
 
-### validateTree Typing
+### Cross-field валидация — через `validate` + `root`
 
 ```typescript
-// WRONG - implicit any
-validateTree((ctx) => { ... });
+// Validator signature: (value, control, root) => ValidationError | null
+// Cross-field правило вешается на ПОЛЕ-НОСИТЕЛЬ ошибки. Соседние поля читаются через `root`.
 
-// CORRECT - explicit typing
-validateTree((ctx: { form: MyForm }) => {
-  if (ctx.form.field1 > ctx.form.field2) {
+// CORRECT — ошибка ложится на path.field1
+validate(path.field1, (_value, _control, root) => {
+  const form = root.getValue();         // typed as TForm
+  if (form.field1 > form.field2) {
     return { code: 'error', message: 'Invalid' };
   }
   return null;
 });
+
+// CORRECT — те же поля через reactive-доступ
+validate(path.address.city, (value, _control, root) => {
+  if (!value && root.address.region.value.value) {
+    return { code: 'cityRequired', message: 'City required when region is set' };
+  }
+  return null;
+});
+
+// WRONG - old API removed
+validateGroup(scopePath, (scope, root) => { ... });  // validateGroup убран
+validateTree((ctx) => { ... });                       // validateTree no longer exists
 ```
 
 ## 16. 14. PROJECT STRUCTURE (COLOCATION)
@@ -1787,18 +1877,18 @@ The "one watcher per trigger" cycle-prevention rule means **never register two w
 
 ```typescript
 // WRONG - bracket notation does NOT work!
-const first = form.items[0]; // undefined or error
-const second = form.items[1]; // undefined or error
+const first = form.items[0];        // undefined or error
+const second = form.items[1];       // undefined or error
 
 // CORRECT - use .at() method
-const first = form.items.at(0); // FormProxy<ItemType> | undefined
-const second = form.items.at(1); // FormProxy<ItemType> | undefined
+const first = form.items.at(0);     // FormProxy<ItemType> | undefined
+const second = form.items.at(1);    // FormProxy<ItemType> | undefined
 
 // CORRECT - iterate with map (most common pattern)
 form.items.map((item, index) => {
   // item is fully typed GroupNode
   item.name.setValue('New Name');
-  item.price.value.value; // read value
+  item.price.value.value;  // read value
 });
 ```
 
@@ -1841,7 +1931,9 @@ function ItemsList({ form }: { form: FormProxy<MyForm> }) {
 
       {length === 0 && <p>No items yet</p>}
 
-      <button onClick={() => form.items.push({ name: '', price: 0 })}>Add Item</button>
+      <button onClick={() => form.items.push({ name: '', price: 0 })}>
+        Add Item
+      </button>
     </div>
   );
 }
@@ -1849,35 +1941,35 @@ function ItemsList({ form }: { form: FormProxy<MyForm> }) {
 
 ### Array Cross-Validation
 
+Cross-field правила по массиву пишутся как обычный `Validator`, вешаются на сам массив
+(или на любое поле-носитель ошибки), а данные читаются через `root`.
+
 ```typescript
 // Validate uniqueness across array items
-validateTree(
-  (ctx: { form: MyForm }) => {
-    const items = ctx.form.items;
-    const names = items.map((item) => item.name.value.value);
-    const uniqueNames = new Set(names);
-
-    if (names.length !== uniqueNames.size) {
-      return { code: 'duplicate', message: 'Item names must be unique' };
-    }
-    return null;
-  },
-  { targetField: 'items' }
-);
+validate(path.items, (_value, _control, root) => {
+  const items = root.items;
+  const names = items.map((item) => item.name.value.value);
+  const uniqueNames = new Set(names);
+
+  if (names.length !== uniqueNames.size) {
+    return { code: 'duplicate', message: 'Item names must be unique' };
+  }
+  return null;
+});
 
 // Validate sum of percentages
-validateTree(
-  (ctx: { form: MyForm }) => {
-    const items = ctx.form.items;
-    const totalPercent = items.reduce((sum, item) => sum + (item.percentage.value.value || 0), 0);
+validate(path.items, (_value, _control, root) => {
+  const items = root.items;
+  const totalPercent = items.reduce(
+    (sum, item) => sum + (item.percentage.value.value || 0),
+    0
+  );
 
-    if (Math.abs(totalPercent - 100) > 0.01) {
-      return { code: 'invalid_total', message: 'Percentages must sum to 100%' };
-    }
-    return null;
-  },
-  { targetField: 'items' }
-);
+  if (Math.abs(totalPercent - 100) > 0.01) {
+    return { code: 'invalid_total', message: 'Percentages must sum to 100%' };
+  }
+  return null;
+});
 ```
 
 ## 22. Cycle Detection Prevention Checklist
@@ -4265,6 +4357,25 @@ export interface ArrayNodeLike {
 
 _Source: src/core/types/index.ts_
 
+### AsyncValidator
+
+**Kind:** `type`
+
+Чистый асинхронный валидатор поля.
+
+Регистрируется через `validateAsync(path, validator, { debounce })`.
+
+**Signature:**
+```typescript
+export type AsyncValidator<TForm, TField> = (
+  value: TField,
+  control: FormProxy<TField>,
+  root: FormProxy<TForm>
+) => Promise<ValidationError | null>;
+```
+
+_Source: src/core/types/validation-schema.ts_
+
 ### AsyncValidatorFn
 
 **Kind:** `type`
@@ -4611,7 +4722,7 @@ _Source: src/core/behavior/types.ts_
 
 **Kind:** `type`
 
-Функция условия для applyWhen
+Функция условия для applyWhen.
 
 **Signature:**
 ```typescript
@@ -4651,61 +4762,6 @@ export interface ConfigWithValue {
 
 _Source: src/core/types/index.ts_
 
-### ContextualAsyncValidatorFn
-
-**Kind:** `type`
-
-Асинхронная функция валидации поля с контекстом
-
-**Signature:**
-```typescript
-export type ContextualAsyncValidatorFn<TForm, TField> = (
-  value: TField,
-  ctx: FormContext<TForm>
-) => Promise<ValidationError | null>;
-```
-
-**Examples:**
-
-```typescript
-validateAsync(path.email, async (value, ctx) => {
-  const exists = await checkEmailExists(value);
-  if (exists) return { code: 'exists', message: 'Email already taken' };
-  return null;
-});
-```
-
-_Source: src/core/types/validation-schema.ts_
-
-### ContextualValidatorFn
-
-**Kind:** `type`
-
-Функция валидации поля с контекстом
-
-Новый паттерн: (value, ctx: FormContext) => ValidationError | null
-
-**Signature:**
-```typescript
-export type ContextualValidatorFn<TForm, TField> = (
-  value: TField,
-  ctx: FormContext<TForm>
-) => ValidationError | null;
-```
-
-**Examples:**
-
-```typescript
-validate(path.email, (value, ctx) => {
-  if (!value) return { code: 'required', message: 'Email required' };
-  const confirm = ctx.form.confirmEmail.value.value;
-  if (value !== confirm) return { code: 'mismatch', message: 'Must match' };
-  return null;
-});
-```
-
-_Source: src/core/types/validation-schema.ts_
-
 ### copyFrom
 
 **Kind:** `function`
@@ -4978,43 +5034,22 @@ _Source: src/core/behavior/behaviors/enable-when.ts_
 
 **Kind:** `function`
 
-Валидатор формата email
+Фабрика валидатора формата email.
 
-Проверяет, что значение соответствует формату email адреса.
 Пустые значения пропускаются (используйте `required` для обязательности).
 
 **Signature:**
 ```typescript
-export function email<TForm, TField extends string | null | undefined = string>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
+export function email<TForm = unknown, TField extends string | undefined = string>(
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование
-validationSchema: (path) => [
-  required(path.email),
-  email(path.email),
-]
-
-// С кастомным сообщением
-email(path.email, { message: 'Введите корректный email адрес' })
-```
-
-```typescript
-// Ошибка валидации
-{
-  code: 'email',
-  message: 'Неверный формат email',
-  params: {}
-}
+validate(path.email, email());
+validate(path.email, email({ message: 'Введите корректный email' }));
 ```
 
 _Source: src/core/validation/validators/email.ts_
@@ -5529,15 +5564,20 @@ const validation = (path: FieldPath<MyForm>) => {
 
 **Signature:**
 ```typescript
-export type FieldPath<T> = {
-  [K in keyof T]: NonNullable<T[K]> extends Array<unknown>
-    ? FieldPathNode<T, T[K], K> // Массивы - не рекурсим (обрабатываются отдельно)
-    : NonNullable<T[K]> extends Date | File | Blob | AnyFunction
-      ? FieldPathNode<T, T[K], K> // Специальные объекты - не рекурсим
-      : NonNullable<T[K]> extends object
-        ? FieldPathNode<T, T[K], K> & FieldPath<NonNullable<T[K]>> // Обычные объекты - рекурсия!
-        : FieldPathNode<T, T[K], K>; // Примитивы
-};
+export type FieldPath<T> =
+  NonNullable<T> extends object
+    ? NonNullable<T> extends Array<unknown> | Date | File | Blob | AnyFunction
+      ? FieldPathNode<unknown, T> // Опаковые объекты — не разворачиваем в mapped type
+      : {
+          [K in keyof T]: NonNullable<T[K]> extends Array<unknown>
+            ? FieldPathNode<T, T[K], K> // Массивы - не рекурсим (обрабатываются отдельно)
+            : NonNullable<T[K]> extends Date | File | Blob | AnyFunction
+              ? FieldPathNode<T, T[K], K> // Специальные объекты - не рекурсим
+              : NonNullable<T[K]> extends object
+                ? FieldPathNode<T, T[K], K> & FieldPath<NonNullable<T[K]>> // Обычные объекты - рекурсия!
+                : FieldPathNode<T, T[K], K>; // Примитивы
+        }
+    : FieldPathNode<unknown, T>;
 ```
 
 _Source: src/core/types/field-path.ts_
@@ -6276,41 +6316,23 @@ _Source: src/core/types/index.ts_
 
 **Kind:** `function`
 
-Проверяет, что дата находится в будущем (не в прошлом)
+Фабрика валидатора, проверяющего что дата не в прошлом.
 
-Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+Пустые и невалидные даты пропускаются.
 
 **Signature:**
 ```typescript
-export function futureDate<TForm, TField extends string | Date | undefined = string | Date>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  options?: ValidateOptions
-): void
+export function futureDate<
+  TForm = unknown,
+  TField extends string | Date | undefined = string | Date,
+>(options?: ValidateOptions): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование - дата события должна быть в будущем
-validationSchema: (path) => [
-  futureDate(path.eventDate),
-]
-
-// С кастомным сообщением
-futureDate(path.appointmentDate, { message: 'Дата записи должна быть в будущем' })
-```
-
-```typescript
-// Ошибка валидации
-{
-  code: 'date_past',
-  message: 'Дата не может быть в прошлом',
-  params: {}
-}
+validate(path.eventDate, futureDate());
+validate(path.appointmentDate, futureDate({ message: 'Дата записи должна быть в будущем' }));
 ```
 
 _Source: src/core/validation/validators/future-date.ts_
@@ -6485,6 +6507,30 @@ export interface GroupNodeConfig<T> {
 
 _Source: src/core/types/index.ts_
 
+### integer
+
+**Kind:** `function`
+
+Фабрика валидатора, проверяющего что число — целое.
+
+Пустые значения и не-числа пропускаются (используйте `required` и `isNumber`).
+
+**Signature:**
+```typescript
+export function integer<TForm = unknown, TField extends number | undefined = number>(
+  options?: ValidateOptions
+): Validator<TForm, TField>
+```
+
+**Examples:**
+
+```typescript
+validate(path.age, integer());
+validate(path.count, integer({ message: 'Должно быть целым числом' }));
+```
+
+_Source: src/core/validation/validators/integer.ts_
+
 ### isArrayNode
 
 **Kind:** `function`
@@ -6520,42 +6566,22 @@ _Source: src/core/utils/type-guards.ts_
 
 **Kind:** `function`
 
-Проверяет, что значение является валидной датой
+Фабрика валидатора, проверяющего что значение — валидная дата.
 
 Пустые значения пропускаются (используйте `required` для обязательности).
 
 **Signature:**
 ```typescript
-export function isDate<TForm, TField extends string | Date | undefined = string | Date>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
+export function isDate<TForm = unknown, TField extends string | Date | undefined = string | Date>(
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование
-validationSchema: (path) => [
-  isDate(path.birthDate),
-  isDate(path.eventDate),
-]
-
-// С кастомным сообщением
-isDate(path.birthDate, { message: 'Введите корректную дату' })
-```
-
-```typescript
-// Ошибка валидации
-{
-  code: 'date_invalid',
-  message: 'Неверный формат даты',
-  params: {}
-}
+validate(path.birthDate, isDate());
+validate(path.eventDate, isDate({ message: 'Введите корректную дату' }));
 ```
 
 _Source: src/core/validation/validators/is-date.ts_
@@ -6650,49 +6676,55 @@ if (isGroupNode(node)) {
 
 _Source: src/core/utils/type-guards.ts_
 
-### max
+### isNumber
 
 **Kind:** `function`
 
-Валидатор максимального числового значения
+Фабрика валидатора, проверяющего что значение — конечное число (не NaN, не строка).
 
-Проверяет, что числовое значение не превышает указанный максимум.
-Пустые значения пропускаются (используйте `required` для обязательности).
+Пустые значения (`null`/`undefined`) пропускаются (используйте `required` для обязательности).
+В отличие от других number-валидаторов, **не** пропускает не-числа — это его задача.
 
 **Signature:**
 ```typescript
-export function max<TForm, TField extends number | null | undefined = number>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  maxValue: number,
+export function isNumber<TForm = unknown, TField extends number | undefined = number>(
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `maxValue` — - Максимально допустимое значение
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование
-validationSchema: (path) => [
-  max(path.quantity, 100),
-  max(path.discount, 50),
-]
+validate(path.amount, isNumber());
+validate(path.amount, isNumber({ message: 'Введите число' }));
+```
+
+_Source: src/core/validation/validators/is-number.ts_
 
-// С кастомным сообщением
-max(path.quantity, 100, { message: 'Максимум 100 единиц' })
+### max
+
+**Kind:** `function`
+
+Фабрика валидатора максимального числового значения.
+
+Пустые значения пропускаются (используйте `required` для обязательности).
+
+**Signature:**
+```typescript
+export function max<TForm = unknown, TField extends number | undefined = number>(
+  maxValue: number,
+  options?: ValidateOptions
+): Validator<TForm, TField>
 ```
 
+**Examples:**
+
 ```typescript
-// Ошибка валидации
-{
-  code: 'max',
-  message: 'Максимальное значение: 100',
-  params: { max: 100, actual: 150 }
-}
+import { validate } from '@reformer/core';
+import { max } from '@reformer/core/validators';
+
+validate(path.quantity, max(100));
+validate(path.discount, max(50, { message: 'Не более 50%' }));
 ```
 
 _Source: src/core/validation/validators/max.ts_
@@ -6701,43 +6733,23 @@ _Source: src/core/validation/validators/max.ts_
 
 **Kind:** `function`
 
-Проверяет, что возраст (вычисленный из даты рождения) не больше указанного
+Фабрика валидатора максимального возраста (по дате рождения).
 
-Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+Пустые и невалидные даты пропускаются.
 
 **Signature:**
 ```typescript
-export function maxAge<TForm, TField extends string | Date | null | undefined = string | Date>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  maxAgeValue: number,
-  options?: ValidateOptions
-): void
+export function maxAge<
+  TForm = unknown,
+  TField extends string | Date | null | undefined = string | Date,
+>(maxAgeValue: number, options?: ValidateOptions): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации (дата рождения)
-- `maxAgeValue` — - Максимально допустимый возраст в годах
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование - максимум 65 лет
-validationSchema: (path) => [
-  maxAge(path.birthDate, 65),
-]
-
-// С кастомным сообщением
-maxAge(path.birthDate, 100, { message: 'Проверьте правильность даты рождения' })
-```
-
-```typescript
-// Ошибка валидации
-{
-  code: 'date_max_age',
-  message: 'Максимальный возраст: 65 лет',
-  params: { maxAge: 65, currentAge: 70 }
-}
+validate(path.birthDate, maxAge(65));
+validate(path.birthDate, maxAge(100, { message: 'Проверьте дату рождения' }));
 ```
 
 _Source: src/core/validation/validators/max-age.ts_
@@ -6746,43 +6758,23 @@ _Source: src/core/validation/validators/max-age.ts_
 
 **Kind:** `function`
 
-Проверяет, что дата не позже указанной максимальной
+Фабрика валидатора максимальной даты (включительно).
 
-Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+Пустые и невалидные даты пропускаются.
 
 **Signature:**
 ```typescript
-export function maxDate<TForm, TField extends string | Date | null | undefined = string | Date>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  maxDateValue: Date,
-  options?: ValidateOptions
-): void
+export function maxDate<
+  TForm = unknown,
+  TField extends string | Date | null | undefined = string | Date,
+>(maxDateValue: Date, options?: ValidateOptions): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `maxDateValue` — - Максимально допустимая дата (включительно)
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование
-validationSchema: (path) => [
-  maxDate(path.birthDate, new Date()), // Не позже сегодня
-]
-
-// С кастомным сообщением
-maxDate(path.endDate, new Date('2025-12-31'), { message: 'Дата не может быть позже конца года' })
-```
-
-```typescript
-// Ошибка валидации
-{
-  code: 'date_max',
-  message: 'Дата должна быть не позднее 31.12.2025',
-  params: { maxDate: Date }
-}
+validate(path.birthDate, maxDate(new Date())); // не позже сегодня
+validate(path.endDate, maxDate(new Date('2025-12-31')));
 ```
 
 _Source: src/core/validation/validators/max-date.ts_
@@ -6791,45 +6783,23 @@ _Source: src/core/validation/validators/max-date.ts_
 
 **Kind:** `function`
 
-Валидатор максимальной длины строки
+Фабрика валидатора максимальной длины строки или массива.
 
-Проверяет, что длина строки не превышает указанный максимум.
 Пустые значения пропускаются (используйте `required` для обязательности).
 
 **Signature:**
 ```typescript
-export function maxLength<TForm, TField extends string | null | undefined = string>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
+export function maxLength<TForm = unknown, TField = unknown>(
   maxLen: number,
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `maxLen` — - Максимальная допустимая длина строки
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование
-validationSchema: (path) => [
-  maxLength(path.name, 50),
-  maxLength(path.bio, 500),
-]
-
-// С кастомным сообщением
-maxLength(path.bio, 500, { message: 'Максимум 500 символов' })
-```
-
-```typescript
-// Ошибка валидации
-{
-  code: 'maxLength',
-  message: 'Максимальная длина: 500 символов',
-  params: { maxLength: 500, actualLength: 512 }
-}
+validate(path.name, maxLength(50));
+validate(path.bio, maxLength(500, { message: 'Max 500 символов' }));
 ```
 
 _Source: src/core/validation/validators/max-length.ts_
@@ -6838,45 +6808,26 @@ _Source: src/core/validation/validators/max-length.ts_
 
 **Kind:** `function`
 
-Валидатор минимального числового значения
+Фабрика валидатора минимального числового значения.
 
-Проверяет, что числовое значение не меньше указанного минимума.
 Пустые значения пропускаются (используйте `required` для обязательности).
 
 **Signature:**
 ```typescript
-export function min<TForm, TField extends number | null | undefined = number>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
+export function min<TForm = unknown, TField extends number | undefined = number>(
   minValue: number,
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `minValue` — - Минимально допустимое значение
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование
-validationSchema: (path) => [
-  min(path.age, 18),
-  min(path.quantity, 1),
-]
+import { validate } from '@reformer/core';
+import { min } from '@reformer/core/validators';
 
-// С кастомным сообщением
-min(path.age, 18, { message: 'Вам должно быть не менее 18 лет' })
-```
-
-```typescript
-// Ошибка валидации
-{
-  code: 'min',
-  message: 'Минимальное значение: 18',
-  params: { min: 18, actual: 16 }
-}
+validate(path.age, min(18));
+validate(path.quantity, min(1, { message: 'Минимум 1' }));
 ```
 
 _Source: src/core/validation/validators/min.ts_
@@ -6885,43 +6836,23 @@ _Source: src/core/validation/validators/min.ts_
 
 **Kind:** `function`
 
-Проверяет, что возраст (вычисленный из даты рождения) не меньше указанного
+Фабрика валидатора минимального возраста (по дате рождения).
 
-Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+Пустые и невалидные даты пропускаются.
 
 **Signature:**
 ```typescript
-export function minAge<TForm, TField extends string | Date | null | undefined = string | Date>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  minAgeValue: number,
-  options?: ValidateOptions
-): void
+export function minAge<
+  TForm = unknown,
+  TField extends string | Date | null | undefined = string | Date,
+>(minAgeValue: number, options?: ValidateOptions): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации (дата рождения)
-- `minAgeValue` — - Минимально допустимый возраст в годах
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование - минимум 18 лет
-validationSchema: (path) => [
-  minAge(path.birthDate, 18),
-]
-
-// С кастомным сообщением
-minAge(path.birthDate, 21, { message: 'Вам должно быть не менее 21 года' })
-```
-
-```typescript
-// Ошибка валидации
-{
-  code: 'date_min_age',
-  message: 'Минимальный возраст: 18 лет',
-  params: { minAge: 18, currentAge: 16 }
-}
+validate(path.birthDate, minAge(18));
+validate(path.birthDate, minAge(21, { message: 'Вам должно быть не менее 21 года' }));
 ```
 
 _Source: src/core/validation/validators/min-age.ts_
@@ -6930,43 +6861,23 @@ _Source: src/core/validation/validators/min-age.ts_
 
 **Kind:** `function`
 
-Проверяет, что дата не раньше указанной минимальной
+Фабрика валидатора минимальной даты (включительно).
 
-Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+Пустые и невалидные даты пропускаются (используйте `required` и `isDate`).
 
 **Signature:**
 ```typescript
-export function minDate<TForm, TField extends string | Date | null | undefined = string | Date>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  minDateValue: Date,
-  options?: ValidateOptions
-): void
+export function minDate<
+  TForm = unknown,
+  TField extends string | Date | null | undefined = string | Date,
+>(minDateValue: Date, options?: ValidateOptions): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `minDateValue` — - Минимально допустимая дата (включительно)
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование
-validationSchema: (path) => [
-  minDate(path.eventDate, new Date('2024-01-01')),
-]
-
-// С кастомным сообщением
-minDate(path.startDate, new Date(), { message: 'Дата должна быть не раньше сегодня' })
-```
-
-```typescript
-// Ошибка валидации
-{
-  code: 'date_min',
-  message: 'Дата должна быть не ранее 01.01.2024',
-  params: { minDate: Date }
-}
+validate(path.eventDate, minDate(new Date('2024-01-01')));
+validate(path.startDate, minDate(new Date(), { message: 'Дата должна быть не раньше сегодня' }));
 ```
 
 _Source: src/core/validation/validators/min-date.ts_
@@ -6975,48 +6886,51 @@ _Source: src/core/validation/validators/min-date.ts_
 
 **Kind:** `function`
 
-Валидатор минимальной длины строки
+Фабрика валидатора минимальной длины строки или массива.
 
-Проверяет, что длина строки не меньше указанного минимума.
 Пустые значения пропускаются (используйте `required` для обязательности).
 
 **Signature:**
 ```typescript
-export function minLength<TForm, TField extends string | null | undefined = string>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
+export function minLength<TForm = unknown, TField = unknown>(
   minLen: number,
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `minLen` — - Минимальная допустимая длина строки
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование
-validationSchema: (path) => [
-  minLength(path.name, 2),
-  minLength(path.password, 8),
-]
+validate(path.name, minLength(2));
+validate(path.password, minLength(8, { message: 'Min 8 символов' }));
+```
+
+_Source: src/core/validation/validators/min-length.ts_
+
+### multipleOf
 
-// С кастомным сообщением
-minLength(path.password, 8, { message: 'Пароль должен быть не менее 8 символов' })
+**Kind:** `function`
+
+Фабрика валидатора, проверяющего что число кратно заданному.
+
+Пустые значения и не-числа пропускаются (используйте `required` и `isNumber`).
+
+**Signature:**
+```typescript
+export function multipleOf<TForm = unknown, TField extends number | undefined = number>(
+  divisor: number,
+  options?: ValidateOptions
+): Validator<TForm, TField>
 ```
 
+**Examples:**
+
 ```typescript
-// Ошибка валидации
-{
-  code: 'minLength',
-  message: 'Минимальная длина: 8 символов',
-  params: { minLength: 8, actualLength: 3 }
-}
+validate(path.price, multipleOf(0.01));
+validate(path.rating, multipleOf(0.5, { message: 'Только шаг 0.5' }));
 ```
 
-_Source: src/core/validation/validators/min-length.ts_
+_Source: src/core/validation/validators/multiple-of.ts_
 
 ### NodeFactory
 
@@ -7087,79 +7001,74 @@ const node = NodeFactory.create({ value: '' }); // → FieldNode<string>
 
 _Source: src/core/factories/node-factory.ts_
 
-### notEmpty
+### nonNegative
 
 **Kind:** `function`
 
-Проверить что массив содержит хотя бы один элемент
+Фабрика валидатора, проверяющего что число неотрицательное (`≥ 0`).
 
-Это удобный алиас для `minLength(field, 1)`, оптимизированный для массивов.
+Пустые значения и не-числа пропускаются (используйте `required` и `isNumber`).
 
 **Signature:**
 ```typescript
-export function notEmpty<TForm, TItem>(
-  fieldPath: FieldPathNode<TForm, TItem[] | undefined> | undefined,
+export function nonNegative<TForm = unknown, TField extends number | undefined = number>(
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Поле-массив для валидации
-- `options` — - Опции валидации (message, params и т.д.)
-
 **Examples:**
 
 ```typescript
-// Простая проверка
-notEmpty(path.properties, { message: 'Добавьте хотя бы один объект имущества' });
+validate(path.quantity, nonNegative());
+validate(path.balance, nonNegative({ message: 'Баланс не может быть отрицательным' }));
+```
 
-// С дополнительными параметрами
-notEmpty(path.coBorrowers, {
-  message: 'Требуется хотя бы один созаемщик',
-  params: { minItems: 1 }
-});
+_Source: src/core/validation/validators/non-negative.ts_
+
+### nonZero
+
+**Kind:** `function`
+
+Фабрика валидатора, проверяющего что число не равно нулю.
+
+Пустые значения и не-числа пропускаются (используйте `required` и `isNumber`).
+
+**Signature:**
+```typescript
+export function nonZero<TForm = unknown, TField extends number | undefined = number>(
+  options?: ValidateOptions
+): Validator<TForm, TField>
 ```
 
-_Source: src/core/validation/validators/array-validators.ts_
+**Examples:**
+
+```typescript
+validate(path.quantity, nonZero());
+validate(path.divisor, nonZero({ message: 'Не может быть нулём' }));
+```
 
-### number
+_Source: src/core/validation/validators/non-zero.ts_
+
+### notEmpty
 
 **Kind:** `function`
 
-Адаптер для number валидатора
-Проверяет, что значение является числом и соответствует заданным ограничениям
+Фабрика валидатора, проверяющего что массив (или строка) не пустой.
 
 **Signature:**
 ```typescript
-export function number<TForm, TField extends number | undefined = number>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  options?: ValidateOptions & {
-    /** Минимальное значение (включительно) */
-    min?: number;
-    /** Максимальное значение (включительно) */
-    max?: number;
-    /** Требовать целое число */
-    integer?: boolean;
-    /** Значение должно быть кратно этому числу */
-    multipleOf?: number;
-    /** Разрешить отрицательные числа (по умолчанию true) */
-    allowNegative?: boolean;
-    /** Разрешить ноль (по умолчанию true) */
-    allowZero?: boolean;
-  }
-): void
+export function notEmpty<TForm = unknown, TField = unknown>(
+  options?: ValidateOptions
+): Validator<TForm, TField>
 ```
 
 **Examples:**
 
 ```typescript
-number(path.age);
-number(path.price, { min: 0, max: 1000000 });
-number(path.percentage, { min: 0, max: 100, integer: true });
-number(path.rating, { min: 0, max: 5, multipleOf: 0.5 });
+validate(path.properties, notEmpty({ message: 'Добавьте хотя бы один элемент' }));
 ```
 
-_Source: src/core/validation/validators/number.ts_
+_Source: src/core/validation/validators/array-validators.ts_
 
 ### ObservableForm
 
@@ -7204,41 +7113,21 @@ _Source: src/core/utils/form-observer.ts_
 
 **Kind:** `function`
 
-Проверяет, что дата находится в прошлом (не в будущем)
+Фабрика валидатора, проверяющего что дата не в будущем.
 
-Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+Пустые и невалидные даты пропускаются.
 
 **Signature:**
 ```typescript
-export function pastDate<TForm, TField extends string | Date | undefined = string | Date>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
+export function pastDate<TForm = unknown, TField extends string | Date | undefined = string | Date>(
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование - дата рождения не может быть в будущем
-validationSchema: (path) => [
-  pastDate(path.birthDate),
-]
-
-// С кастомным сообщением
-pastDate(path.birthDate, { message: 'Дата рождения не может быть в будущем' })
-```
-
-```typescript
-// Ошибка валидации
-{
-  code: 'date_future',
-  message: 'Дата не может быть в будущем',
-  params: {}
-}
+validate(path.birthDate, pastDate({ message: 'Дата рождения не может быть в будущем' }));
 ```
 
 _Source: src/core/validation/validators/past-date.ts_
@@ -7285,47 +7174,23 @@ _Source: src/core/utils/field-path-navigator.ts_
 
 **Kind:** `function`
 
-Валидатор паттерна (регулярного выражения)
+Фабрика валидатора регулярного выражения.
 
-Проверяет, что значение соответствует указанному регулярному выражению.
 Пустые значения пропускаются (используйте `required` для обязательности).
 
 **Signature:**
 ```typescript
-export function pattern<TForm, TField extends string | null | undefined = string>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
+export function pattern<TForm = unknown, TField extends string | undefined = string>(
   regex: RegExp,
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `regex` — - Регулярное выражение для проверки
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Только буквы
-pattern(path.name, /^[а-яА-Яa-zA-Z]+$/)
-
-// Только цифры
-pattern(path.code, /^\d+$/)
-
-// С кастомным сообщением
-pattern(path.username, /^[a-z0-9_]+$/i, {
-  message: 'Только латинские буквы, цифры и подчёркивание'
-})
-```
-
-```typescript
-// Ошибка валидации
-{
-  code: 'pattern',
-  message: 'Значение не соответствует требуемому формату',
-  params: { pattern: '^[a-z]+$' }
-}
+validate(path.name, pattern(/^[а-яА-Яa-zA-Z]+$/));
+validate(path.code, pattern(/^\d+$/, { message: 'Только цифры' }));
 ```
 
 _Source: src/core/validation/validators/pattern.ts_
@@ -7334,26 +7199,22 @@ _Source: src/core/validation/validators/pattern.ts_
 
 **Kind:** `function`
 
-Адаптер для phone валидатора
-Поддерживает опциональные поля (string | undefined)
+Фабрика валидатора номера телефона.
+
+Пустые значения пропускаются (используйте `required` для обязательности).
 
 **Signature:**
 ```typescript
-export function phone<TForm, TField extends string | null | undefined = string>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  options?: ValidateOptions & {
-    /** Формат телефона */
-    format?: PhoneFormat;
-  }
-): void
+export function phone<TForm = unknown, TField extends string | undefined = string>(
+  options?: PhoneValidatorOptions
+): Validator<TForm, TField>
 ```
 
 **Examples:**
 
 ```typescript
-phone(path.phoneNumber);
-phone(path.phoneNumber, { format: 'ru' });
-phone(path.phoneNumber, { format: 'international', message: 'Неверный формат телефона' });
+validate(path.phone, phone());
+validate(path.phone, phone({ format: 'ru' }));
 ```
 
 _Source: src/core/validation/validators/phone.ts_
@@ -7362,8 +7223,6 @@ _Source: src/core/validation/validators/phone.ts_
 
 **Kind:** `type`
 
-Формат телефона для валидации
-
 **Signature:**
 ```typescript
 export type PhoneFormat = 'international' | 'ru' | 'us' | 'any';
@@ -7411,47 +7270,29 @@ _Source: src/core/utils/registry-stack.ts_
 
 **Kind:** `function`
 
-Валидатор обязательного поля
+Фабрика валидатора обязательного поля.
+
+Возвращает чистую функцию-валидатор `(value, control, root)`. Передаётся в `validate()`.
 
-Проверяет, что поле имеет непустое значение.
 Пустыми считаются: `null`, `undefined`, `''` (пустая строка).
 Для boolean полей требуется значение `true`.
 
 **Signature:**
 ```typescript
-export function required<TForm, TField>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
+export function required<TForm = unknown, TField = unknown>(
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование
-validationSchema: (path, { validate }) => [
-  required(path.name),
-  required(path.email),
-]
-
-// С кастомным сообщением
-required(path.phone, { message: 'Укажите номер телефона' })
-
-// Для checkbox (требует true)
-required(path.agreeToTerms, { message: 'Необходимо принять условия' })
-```
+import { validate } from '@reformer/core';
+import { required } from '@reformer/core/validators';
 
-```typescript
-// Ошибка валидации
-{
-  code: 'required',
-  message: 'Поле обязательно для заполнения',
-  params: {}
-}
+validate(path.email, required());
+validate(path.phone, required({ message: 'Укажите номер телефона' }));
+validate(path.agreeToTerms, required({ message: 'Необходимо принять условия' }));
 ```
 
 _Source: src/core/validation/validators/required.ts_
@@ -8166,60 +8007,6 @@ export interface TransformValueOptions {
 
 _Source: src/core/behavior/behaviors/transform-value.ts_
 
-### TreeValidationContextImpl
-
-**Kind:** `class`
-
-Контекст cross-field валидации. Передаётся в `validateTree`/`validateForm`
-callback'и — напрямую инстанцировать не нужно.
-
-**Signature:**
-```typescript
-export class TreeValidationContextImpl<TForm> extends BaseValidationContext<TForm> { /* … */ }
-```
-
-**Examples:**
-
-```typescript
-import { validateForm } from '@reformer/core';
-
-validateForm(form, (ctx) => {
-  // ctx — экземпляр TreeValidationContextImpl
-  if (ctx.form.startDate.value > ctx.form.endDate.value) {
-    return [{ code: 'date-range', message: 'Дата начала позже даты окончания' }];
-  }
-  return [];
-});
-```
-
-_Source: src/core/validation/validation-context.ts_
-
-### TreeValidatorFn
-
-**Kind:** `type`
-
-Функция cross-field валидации
-
-**Signature:**
-```typescript
-export type TreeValidatorFn<TForm> = (ctx: FormContext<TForm>) => ValidationError | null;
-```
-
-**Examples:**
-
-```typescript
-validateTree((ctx) => {
-  const password = ctx.form.password.value.value;
-  const confirm = ctx.form.confirmPassword.value.value;
-  if (password !== confirm) {
-    return { code: 'mismatch', message: 'Passwords must match' };
-  }
-  return null;
-});
-```
-
-_Source: src/core/types/validation-schema.ts_
-
 ### uniqueId
 
 **Kind:** `function`
@@ -8293,28 +8080,23 @@ _Source: src/core/types/index.ts_
 
 **Kind:** `function`
 
-Адаптер для URL валидатора
-Поддерживает опциональные поля (string | undefined)
+Фабрика валидатора URL.
+
+Пустые значения пропускаются (используйте `required` для обязательности).
 
 **Signature:**
 ```typescript
-export function url<TForm, TField extends string | null | undefined = string>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  options?: ValidateOptions & {
-    /** Требовать наличие протокола (http:// или https://) */
-    requireProtocol?: boolean;
-    /** Разрешенные протоколы */
-    allowedProtocols?: string[];
-  }
-): void
+export function url<TForm = unknown, TField extends string | undefined = string>(
+  options?: UrlValidatorOptions
+): Validator<TForm, TField>
 ```
 
 **Examples:**
 
 ```typescript
-url(path.website);
-url(path.website, { message: 'Введите корректный URL' });
-url(path.website, { requireProtocol: true });
+validate(path.website, url());
+validate(path.website, url({ requireProtocol: true }));
+validate(path.website, url({ allowedProtocols: ['https'] }));
 ```
 
 _Source: src/core/validation/validators/url.ts_
@@ -8809,14 +8591,16 @@ _Source: src/hooks/useHiddenCondition.ts_
 
 **Kind:** `function`
 
-Зарегистрировать кастомный синхронный валидатор для поля
-Поддерживает опциональные поля
+Зарегистрировать синхронный валидатор для поля.
+
+Принимает чистую функцию-валидатор `(value, control, root) => error | null`,
+либо фабрику из `@reformer/core/validators` (например, `required()`).
 
 **Signature:**
 ```typescript
 export function validate<TForm, TField>(
   fieldPath: FieldPathNode<TForm, TField> | undefined,
-  validatorFn: ContextualValidatorFn<TForm, TField>,
+  validator: Validator<TForm, TField>,
   options?: ValidateOptions
 ): void
 ```
@@ -8824,20 +8608,14 @@ export function validate<TForm, TField>(
 **Examples:**
 
 ```typescript
-validate(path.birthDate, (ctx: ValidationContext<TForm, TField>) => {
-  const birthDate = new Date(ctx.value());
-  const age = calculateAge(birthDate);
-
-  if (age < 18) {
-    return {
-      code: 'tooYoung',
-      message: 'Заемщику должно быть не менее 18 лет',
-    };
-  }
-
+// Кастомный валидатор
+validate(path.birthDate, (value, _control, root) => {
+  const age = calculateAge(new Date(value));
+  if (age < 18) return { code: 'tooYoung', message: 'Только 18+' };
   return null;
 });
-```
+
+// Фабрика из
 
 _Source: src/core/validation/core/validate.ts_
 
@@ -8845,13 +8623,15 @@ _Source: src/core/validation/core/validate.ts_
 
 **Kind:** `function`
 
-Зарегистрировать асинхронный валидатор для поля
+Зарегистрировать асинхронный валидатор для поля.
+
+Принимает чистую async-функцию `(value, control, root) => Promise<error | null>`.
 
 **Signature:**
 ```typescript
 export function validateAsync<TForm, TField>(
   fieldPath: FieldPathNode<TForm, TField>,
-  validatorFn: ContextualAsyncValidatorFn<TForm, TField>,
+  validator: AsyncValidator<TForm, TField>,
   options?: ValidateAsyncOptions
 ): void
 ```
@@ -8861,23 +8641,16 @@ export function validateAsync<TForm, TField>(
 ```typescript
 validateAsync(
   path.inn,
-  async (ctx: ValidationContext<TForm, TField>) => {
-    const inn = ctx.value();
-    if (!inn) return null;
-
+  async (value, _control, _root) => {
+    if (!value) return null;
     const response = await fetch('/api/validate-inn', {
       method: 'POST',
-      body: JSON.stringify({ inn }),
+      body: JSON.stringify({ inn: value }),
     });
-
     const data = await response.json();
     if (!data.valid) {
-      return {
-        code: 'invalidInn',
-        message: 'ИНН не найден в базе данных ФНС',
-      };
+      return { code: 'invalidInn', message: 'ИНН не найден в базе ФНС' };
     }
-
     return null;
   },
   { debounce: 1000 }
@@ -8890,7 +8663,7 @@ _Source: src/core/validation/core/validate-async.ts_
 
 **Kind:** `interface`
 
-Опции для функции validateAsync
+Опции для функции validateAsync.
 
 **Signature:**
 ```typescript
@@ -8968,7 +8741,7 @@ _Source: src/core/validation/validate-form.ts_
 
 **Kind:** `function`
 
-Применить validation schema к каждому элементу массива
+Применить validation schema к каждому элементу массива.
 
 Регистрирует схему валидации, которая будет автоматически применяться
 к каждому элементу ArrayNode (как существующим, так и новым).
@@ -8981,21 +8754,13 @@ export function validateItems<TForm, TItem>(
 ): void
 ```
 
-**Parameters:**
-- `fieldPath` — - Поле-массив для валидации элементов
-- `itemSchemaFn` — - Validation schema для одного элемента
-
 **Examples:**
 
 ```typescript
 import { propertyValidation } from './property-validation';
 
-// В additionalValidation
 applyWhen(path.hasProperty, (value) => value === true, (path) => {
-  // Проверка что массив не пустой
-  notEmpty(path.properties, { message: 'Добавьте хотя бы один объект имущества' });
-
-  // Валидация каждого элемента
+  validate(path.properties, notEmpty({ message: 'Добавьте хотя бы один объект' }));
   validateItems(path.properties, propertyValidation);
 });
 ```
@@ -9006,7 +8771,7 @@ _Source: src/core/validation/validators/array-validators.ts_
 
 **Kind:** `interface`
 
-Опции для функции validate
+Опции для функции validate.
 
 **Signature:**
 ```typescript
@@ -9020,88 +8785,6 @@ export interface ValidateOptions {
 
 _Source: src/core/types/validation-schema.ts_
 
-### validateTree
-
-**Kind:** `function`
-
-Зарегистрировать cross-field валидатор
-
-Используется для валидации, которая зависит от нескольких полей
-
-**Signature:**
-```typescript
-export function validateTree<TForm>(
-  validatorFn: TreeValidatorFn<TForm>,
-  options?: ValidateTreeOptions
-): void
-```
-
-**Examples:**
-
-```typescript
-// Явная типизация ctx для избежания implicit any
-validateTree(
-  (ctx: { form: MyForm }) => {
-    if (ctx.form.initialPayment && ctx.form.propertyValue) {
-      if (ctx.form.initialPayment > ctx.form.propertyValue) {
-        return {
-          code: 'initialPaymentTooHigh',
-          message: 'Первоначальный взнос не может превышать стоимость',
-        };
-      }
-    }
-    return null;
-  },
-  { targetField: 'initialPayment' }
-);
-```
-
-_Source: src/core/validation/core/validate-tree.ts_
-
-### ValidateTreeOptions
-
-**Kind:** `interface`
-
-Опции для функции validateTree
-
-**Signature:**
-```typescript
-export interface ValidateTreeOptions {
-  /** Поле, к которому привязать ошибку */
-  targetField?: string;
-}
-```
-
-_Source: src/core/types/validation-schema.ts_
-
-### ValidationContextImpl
-
-**Kind:** `class`
-
-Контекст валидации одного поля. Создаётся фреймворком и передаётся в валидаторы
-(`required`, `validate`, …) — напрямую инстанцировать не нужно.
-
-**Signature:**
-```typescript
-export class ValidationContextImpl<TForm, TField> extends BaseValidationContext<TForm> { /* … */ }
-```
-
-**Examples:**
-
-```typescript
-import { validate } from '@reformer/core/validators';
-
-validate(path.password, (value, ctx) => {
-  // ctx — экземпляр ValidationContextImpl, доступ к ctx.form для cross-field логики
-  if (value !== ctx.form.confirmPassword.value) {
-    return { code: 'mismatch', message: 'Пароли не совпадают' };
-  }
-  return null;
-});
-```
-
-_Source: src/core/validation/validation-context.ts_
-
 ### ValidationError
 
 **Kind:** `interface`
@@ -9130,14 +8813,18 @@ _Source: src/core/types/index.ts_
 Каждый экземпляр GroupNode создает собственный реестр (композиция).
 Устраняет race conditions и изолирует формы друг от друга.
 
-Наследует AbstractRegistry для унификации:
-- Управления global stack
-- Template methods begin/end registration
+Context stack используется для tracking текущего активного реестра:
+- beginRegistration() помещает this в global stack
+- endRegistration() извлекает из global stack
+- getCurrent() возвращает текущий активный реестр
 
 **Signature:**
 ```typescript
-export class ValidationRegistry extends AbstractRegistry<ValidatorRegistration> {
-  /** Внутренний стек контекстов для управления condition blocks */ /* … */ }
+export class ValidationRegistry {
+  /**
+   * Global stack активных реестров
+   * Используется для изоляции форм друг от друга
+   */ /* … */ }
 ```
 
 **Examples:**
@@ -9160,9 +8847,9 @@ _Source: src/core/validation/validation-registry.ts_
 
 **Kind:** `type`
 
-Функция validation schema
+Функция validation schema.
 
-Принимает FieldPath и определяет все правила валидации для формы
+Принимает FieldPath и определяет все правила валидации для формы.
 
 **Signature:**
 ```typescript
@@ -9171,6 +8858,36 @@ export type ValidationSchemaFn<T> = (path: FieldPath<T>) => void;
 
 _Source: src/core/types/validation-schema.ts_
 
+### Validator
+
+**Kind:** `type`
+
+Чистый синхронный валидатор поля.
+
+Принимает значение поля, прокси текущего поля (control) и прокси корня формы (root).
+Возвращает ValidationError либо null. Не знает про реестр валидации.
+
+**Signature:**
+```typescript
+export type Validator<TForm, TField> = (
+  value: TField,
+  control: FormProxy<TField>,
+  root: FormProxy<TForm>
+) => ValidationError | null;
+```
+
+**Examples:**
+
+```typescript
+const isAdult: Validator<MyForm, number> = (value, control, root) => {
+  if (value < 18) return { code: 'tooYoung', message: '18+' };
+  return null;
+};
+validate(path.age, isAdult);
+```
+
+_Source: src/core/types/validation-schema.ts_
+
 ### ValidatorFn
 
 **Kind:** `type`
@@ -9194,12 +8911,10 @@ _Source: src/core/types/index.ts_
 ```typescript
 export interface ValidatorRegistration {
   fieldPath: string;
-  type: 'sync' | 'async' | 'tree';
-  validator:
-    | ContextualValidatorFn<unknown, unknown>
-    | ContextualAsyncValidatorFn<unknown, unknown>
-    | TreeValidatorFn<unknown>;
-  options?: ValidateOptions | ValidateAsyncOptions | ValidateTreeOptions;
+  type: 'sync' | 'async' | 'array-items';
+  validator: Validator<unknown, unknown> | AsyncValidator<unknown, unknown>;
+  options?: ValidateOptions | ValidateAsyncOptions;
+  /** Для условной валидации (applyWhen). */
   condition?: {
     fieldPath: string;
     conditionFn: ConditionFn<unknown>;