@reformer/core 11.0.0-beta.3 → 11.0.0-beta.5

package/dist/behaviors.d.ts

@@ -1,2 +1,2 @@
-export * from './form/behaviors'
+export * from './form/behaviors/index'
 export {}

package/dist/behaviors.js

@@ -1,7 +1,7 @@
 import { effect as j } from "@preact/signals-core";
-import { m as $, u as k, i as C } from "./form-model-DhW2HZOB.js";
-import { d as x, a as M, w as F, t as O, r as A, s as D, b as G } from "./behaviors-value-C7dSEhCc.js";
-import { e as T } from "./behaviors-node-DGEFMTQu.js";
+import { d as $, a as C, w as F, t as M, r as O, s as A, b as D } from "./behaviors-value-C7dSEhCc.js";
+import { i as G, m as k, u as x } from "./model-signals-proxy-mV3WGdlO.js";
+import { e as T } from "./node-DGEFMTQu.js";
 let p = null;
 function P(e) {
   if (!p)
@@ -37,9 +37,9 @@ function h(e) {
   s(j(e));
 }
 function g(e) {
-  x(e);
+  $(e);
 }
-const m = (e) => typeof e == "object" && e !== null && typeof e.peek == "function" && !C(e), B = (e) => Array.isArray(e) ? e : [e];
+const m = (e) => typeof e == "object" && e !== null && typeof e.peek == "function" && !G(e), B = (e) => Array.isArray(e) ? e : [e];
 function E(e) {
   const t = {};
   for (const n of Object.keys(e)) {
@@ -54,26 +54,7 @@ function W(e, t) {
     m(o) ? o.value = t?.[n] : W(o, t?.[n] ?? {});
   }
 }
-function R(e) {
-  if (!e) return;
-  const { form: t } = y();
-  return t.getFieldByPath(e);
-}
 function S(e) {
-  return new Proxy(
-    {},
-    {
-      get: (t, n) => {
-        if (n === "$") return e;
-        if (typeof n != "string") return;
-        const o = e[n];
-        if (o != null)
-          return m(o) ? o.value : S(o);
-      }
-    }
-  );
-}
-function V(e) {
   return (t) => {
     try {
       t();
@@ -88,9 +69,17 @@ function V(e) {
     }
   };
 }
+function _(e, t) {
+  return t.split(".").reduce((n, o) => n?.[o], e);
+}
+function R(e) {
+  if (!e) return;
+  const { form: t } = y();
+  return t.getFieldByPath(e);
+}
 function X(e, t, n) {
-  $(e), s(() => k(e));
-  const o = V(e);
+  k(e), s(() => x(e));
+  const o = S(e);
   h(() => {
     if (n?.when && !n.when()) return;
     const r = t();
@@ -100,8 +89,8 @@ function X(e, t, n) {
   });
 }
 function Y(e, t, n, o) {
-  $(t), s(() => k(t));
-  const r = V(t);
+  k(t), s(() => x(t));
+  const r = S(t);
   h(() => {
     const c = e.map((f) => f.value);
     if (o?.when && !o.when(...c)) return;
@@ -113,7 +102,7 @@ function Y(e, t, n, o) {
 }
 function Z(e, t, n) {
   if (m(e) && m(t)) {
-    s(M(e, t, n));
+    s(C(e, t, n));
     return;
   }
   const o = e, r = t;
@@ -127,7 +116,7 @@ function q(e, t, n) {
   const r = (c) => {
     o?.abort(), o = new AbortController();
     const { signal: i } = o;
-    x(() => t(c, { signal: i }));
+    $(() => t(c, { signal: i }));
   };
   if (!n?.debounce)
     s(F(e, r, { immediate: n?.immediate }));
@@ -163,19 +152,30 @@ function L(e, t, n) {
   });
 }
 function ne(e, t) {
-  s(O(e, t));
+  s(M(e, t));
 }
 function te(e, t, n) {
-  s(A(e, t, n));
+  s(O(e, t, n));
 }
 function oe(e, t, n) {
-  s(D(e, t, n));
+  s(A(e, t, n));
 }
 function re(e, t) {
-  s(G(e, t));
+  s(D(e, t));
 }
-function _(e, t) {
-  return t.split(".").reduce((n, o) => n?.[o], e);
+function V(e) {
+  return new Proxy(
+    {},
+    {
+      get: (t, n) => {
+        if (n === "$") return e;
+        if (typeof n != "string") return;
+        const o = e[n];
+        if (o != null)
+          return m(o) ? o.value : V(o);
+      }
+    }
+  );
 }
 function N(e) {
   return new Proxy(
@@ -276,7 +276,7 @@ function fe(e, t) {
     const r = o, c = r.__path;
     if (!c) continue;
     const i = n ? n.getFieldByPath(c) : void 0, f = i ? i.getProxy?.() ?? i : void 0;
-    s(t.__run(S(r), f));
+    s(t.__run(V(r), f));
   }
 }
 export {

package/dist/create-model-Dxh9cfLp.js

@@ -0,0 +1,97 @@
+import { s as p, r as v, b as f, G as g } from "./model-signals-proxy-mV3WGdlO.js";
+function a(t) {
+  if (t)
+    return t.kind === "group" ? d(t) : t.kind === "array" ? w(t) : t.read();
+}
+function w(t) {
+  const s = {
+    get length() {
+      return t.items.value.length;
+    },
+    push: (e) => t.push(e),
+    insertAt: (e, n) => t.insertAt(e, n),
+    removeAt: (e) => t.removeAt(e),
+    move: (e, n) => t.move(e, n),
+    swap: (e, n) => t.swap(e, n),
+    clear: () => t.clear(),
+    at: (e) => a(t.items.value[e]),
+    map: (e) => t.items.value.map((n, i) => e(a(n), i)),
+    forEach: (e) => t.items.value.forEach((n, i) => e(a(n), i)),
+    toArray: () => t.peek(),
+    [Symbol.iterator]: function* () {
+      const e = t.items.value;
+      for (let n = 0; n < e.length; n++) yield a(e[n]);
+    }
+  };
+  return new Proxy(s, {
+    get: (e, n, i) => n === "__path" ? t.path : typeof n == "string" && f(n) ? a(t.items.value[Number(n)]) : Reflect.get(e, n, i),
+    has: (e, n) => typeof n == "string" && f(n) ? Number(n) < t.items.value.length : Reflect.has(e, n)
+  });
+}
+const u = /* @__PURE__ */ new Set([
+  "$",
+  "get",
+  "set",
+  "patch",
+  "isDirty",
+  "reset",
+  "captureInitial",
+  "signalAt"
+]), h = /* @__PURE__ */ new WeakMap(), m = /* @__PURE__ */ new WeakMap();
+function d(t) {
+  const s = h.get(t);
+  if (s) return s;
+  const e = {
+    $: p(t),
+    get: () => t.peek(),
+    set: (i) => t.set(i),
+    patch: (i) => t.set(i),
+    isDirty: () => t.dirty(),
+    reset: () => t.resetToInitial(),
+    captureInitial: () => t.captureInitial(),
+    signalAt: (i) => v(t, i)
+  }, n = new Proxy(
+    {},
+    {
+      get: (i, r) => {
+        if (r === "__path") return t.path;
+        if (typeof r != "string") return;
+        const c = t.children.get(r);
+        if (c) return a(c);
+        if (u.has(r)) return e[r];
+      },
+      set: (i, r, c) => {
+        if (typeof r != "string") return !1;
+        const o = t.children.get(r);
+        return o ? (o.set(c), !0) : !1;
+      },
+      has: (i, r) => typeof r == "string" && (t.children.has(r) || u.has(r)),
+      ownKeys: () => [...t.children.keys()],
+      getOwnPropertyDescriptor: (i, r) => typeof r == "string" && t.children.has(r) ? { enumerable: !0, configurable: !0 } : void 0
+    }
+  );
+  return h.set(t, n), m.set(n, t), n;
+}
+function l(t, s) {
+  if (t.kind === "leaf") {
+    s(t.signal);
+    return;
+  }
+  if (t.kind === "group") {
+    for (const e of t.children.values()) l(e, s);
+    return;
+  }
+  for (const e of t.items.value) l(e, s);
+}
+function A(t, s) {
+  const e = m.get(t);
+  e && l(e, s);
+}
+function _(t) {
+  const s = new g(t, "");
+  return d(s);
+}
+export {
+  _ as c,
+  A as e
+};

package/dist/form/behaviors/collections.d.ts

@@ -0,0 +1,50 @@
+import { Signal } from '@preact/signals-core';
+import { FormModel } from '../../index';
+import { FormBehavior } from './types';
+/**
+ * Применить под-схему к КАЖДОМУ элементу динамического массива (per-item поведение).
+ * Реагирует на добавление/удаление строк: новым строкам поведение применяется, удалённым — отписывается.
+ *
+ * Под-схема получает scope строки: `model` (под-модель строки — `row.$.field`) и `form` (нода строки).
+ * - Value-операции (`compute`/`copyFrom`/`transformValue` на `row.$.*`) работают всегда.
+ * - Node-операции (`enableWhen`/`updateComponentProps`/`reset` через `form.*`) требуют, чтобы массив был
+ *   МАТЕРИАЛИЗОВАН в форме (узел `{ array, item }` в схеме) — тогда `form` строки = та же нода, что
+ *   рендерится, а её сигналы зарегистрированы (`enableWhen` резолвит ноду). Без материализации доступ
+ *   к `form.*` бросит понятную ошибку (см. {@link unmaterializedRowForm}).
+ *
+ * @example
+ * applyEach(model.$.items, defineFormBehavior<Item>(({ model: row, form }) => {
+ *   compute(row.$.lineTotal, () => row.qty * row.price);    // value-op — всегда
+ *   enableWhen(row.$.discount, () => row.qty > 10);          // node-op — нужна материализация массива
+ * }));
+ */
+export declare function applyEach<TItem>(array: object, itemSchema: FormBehavior<TItem>): void;
+/**
+ * Взаимное исключение булева флага среди строк массива (single-selection — «единственный primary»).
+ * Когда флаг строки становится true, у остальных строк он сбрасывается в false. Не хрупок к push:
+ * новые строки с флагом false исключения не запускают.
+ *
+ * @example
+ * exclusiveFlag(model.$.contacts, (row) => row.$.primary);
+ */
+export declare function exclusiveFlag<TItem>(array: object, getFlag: (row: FormModel<TItem>) => Signal<boolean>): void;
+/**
+ * Агрегатная запись в строки массива. `derive(snapshot)` получает СНИМОК строк и возвращает список
+ * `{ index, patch }`, который применяется к строкам. Записи КОАЛЕСИРУЮТСЯ в один отложенный проход на
+ * финальном состоянии — поэтому массовые синхронные мутации (push в цикле) не вызывают каскад на
+ * промежуточных состояниях. `derive` должна сходиться (на фикспоинте возвращать те же значения).
+ *
+ * @example
+ * // последняя строка = 100 − Σ(остальные)
+ * aggregateInto(model.$.rows, (rows) => {
+ *   const n = rows.length; if (n === 0) return [];
+ *   const others = rows.slice(0, n - 1).reduce((s, r) => s + r.percent, 0);
+ *   return [{ index: n - 1, patch: { percent: 100 - others } }];
+ * });
+ */
+export declare function aggregateInto<TItem>(array: object, derive: (rows: TItem[]) => Array<{
+    index: number;
+    patch: Partial<TItem>;
+}>): void;
+/** Применить под-схему к одному или нескольким полям-группам (переиспользование). */
+export declare function apply<TField>(targets: object | object[], subSchema: FormBehavior<TField>): void;

package/dist/form/behaviors/context.d.ts

@@ -0,0 +1,23 @@
+import { BehaviorCleanup } from '../../index';
+import { BehaviorScope, FormBehavior } from './types';
+/** Зарегистрировать произвольную отписку в активной схеме. */
+export declare function onDispose(cleanup: BehaviorCleanup): void;
+/** Текущий scope ({ model, form }) активной схемы (escape hatch для кросс-операторов). */
+export declare function getScope<T>(): BehaviorScope<T>;
+/**
+ * Описать поведение формы декларативно. Возвращает {@link FormBehavior} для `createForm({ behavior })`.
+ *
+ * @example
+ * ```ts
+ * export const myBehavior = defineFormBehavior<MyForm>(({ model, form }) => {
+ *   compute(model.$.total, () => model.price * model.qty);
+ *   enableWhen([model.$.city], () => Boolean(model.country));
+ *   onChange(model.$.country, async (c) => form.city.updateComponentProps({ options: await load(c) }));
+ * });
+ * ```
+ */
+export declare function defineFormBehavior<T>(setup: (scope: BehaviorScope<T>) => void): FormBehavior<T>;
+/** Реактивный эффект (авто-dispose). Колбэк может вернуть собственный cleanup. */
+export declare function effect(fn: () => void | (() => void)): void;
+/** Отложенная запись вне effect-контекста (микротаск) — защита от «Cycle detected». */
+export declare function defer(fn: () => void): void;

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

@@ -0,0 +1,28 @@
+/**
+ * Декларативный контракт схемы поведения формы — `@reformer/core/behaviors`.
+ *
+ * Свободные операторы (`compute`/`copyFrom`/`enableWhen`/`onChange`/…) вызываются внутри
+ * `defineFormBehavior(({ model, form }) => { … })` и САМИ регистрируют свои отписки в ambient-стоке —
+ * автор схемы не видит ни массива `cleanups`, ни `.push`, ни вызовов через точку. Жизненным циклом
+ * владеет форма (`createForm({ behavior })`). Операторы — тонкие обёртки над примитивами слоя данных
+ * ({@link module:model/behaviors-value}); пользовательские операторы пишутся так же и неотличимы от встроенных.
+ *
+ * Граница ответственности: контракт НЕ управляет валидацией — это отдельный слой
+ * (`defineValidationSchema` + раннер `validateModel` из `@reformer/core/validation`), он остаётся
+ * владельцем `errors`. Это сделано намеренно. Для редких крайних случаев
+ * behavior-driven валидации (cross-field, async-uniqueness) можно написать собственный оператор поверх
+ * `effect`/`onChange` + `node.setErrors(...)` — он будет неотличим от встроенного; примеры см. в
+ * tests/behaviors/web-scenarios (W1/W3). В общем случае правила валидности держите в слое валидации.
+ *
+ * Модуль разложен по зонам ответственности: `./types` — контракт схемы, `./context` — ambient-сток
+ * и низкоуровневый набор авторинга, `./internals` — чистые утилиты, `./operators` — операторы над
+ * полем и группой, `./collections` — операторы над массивами и под-моделями.
+ *
+ * @group Behaviors
+ * @module form/behaviors
+ */
+export type { BehaviorScope, FormBehavior, ChangeContext } from './types';
+export type { Signal, ReadonlySignal, BehaviorCleanup } from './types';
+export { onDispose, getScope, defineFormBehavior, effect, defer } from './context';
+export { compute, computeFrom, copyFrom, onChange, enableWhen, disableWhen, transformValue, resetWhen, syncFields, revalidateWhen, } from './operators';
+export { applyEach, exclusiveFlag, aggregateInto, apply } from './collections';

package/dist/form/behaviors/internals.d.ts

@@ -0,0 +1,26 @@
+import { Signal } from '@preact/signals-core';
+/** Групповой узел дерева `$`: набор дочерних сигналов плюс служебный путь. */
+export type GroupSignals = Record<string, unknown> & {
+    __path?: string;
+};
+/**
+ * Лист модели, а не контейнерный узел дерева `$`.
+ *
+ * Узлы-группы/массивы тоже структурно совместимы с `ReadonlySignal` (у них есть `peek`/`value`/
+ * `subscribe` над агрегатом поддерева), поэтому одного duck-typing по `peek` мало: без отсечки по
+ * `isModelContainerSignal` группа уходила бы в скалярные ветки операторов — `enableWhen` молча
+ * терял бы `enableGroup`, `apply` получал бы значение вместо под-модели, а `copyFrom` — запись в
+ * read-only агрегат вместо рекурсивного `writeGroup`.
+ */
+export declare const isLeafSignal: (v: unknown) => v is Signal<unknown>;
+export declare const asArray: <X>(v: X | X[]) => X[];
+export declare function readGroup(g: GroupSignals): Record<string, unknown>;
+export declare function writeGroup(g: GroupSignals, val: Record<string, unknown>): void;
+/**
+ * Guard от расходящихся циклов пересчёта (F7). Расходящийся взаимный compute/computeFrom (без
+ * стабилизации) preact обрывает невнятным «Cycle detected» — перехватываем и заменяем понятной
+ * ошибкой с именем поля и подсказкой. Сходящиеся compute (упираются в peek-guard) и массовые
+ * синхронные мутации цикла не порождают → не затрагиваются.
+ */
+export declare function makeCycleGuard(target: Signal<unknown>): (write: () => void) => void;
+export declare function getByPath(root: unknown, path: string): any;

package/dist/form/{behaviors-node.d.ts → behaviors/node.d.ts}

@@ -1,5 +1,5 @@
 import { ReadonlySignal } from '@preact/signals-core';
-import { BehaviorCleanup } from '../state/behaviors-value';
+import { BehaviorCleanup } from '../../model/behaviors-value';
 /**
  * Условное включение поля (state-операция). Резолвит ноду по сигналу-цели через реестр
  * сигнал→нода (заполняется `createForm`) и вызывает `enable()`/`disable()` (+`reset()` при
@@ -18,7 +18,7 @@ import { BehaviorCleanup } from '../state/behaviors-value';
  * включают disabled-поля, мусор утечёт в payload. Это аналог правила #13 гайда add-behavior,
  * которое сегодня сформулировано только для `copyFrom`; для `compute` то же ограничение обязательно.
  *
- * @group Model
+ * @group Form
  * @example
  * ```typescript
  * enableWhen(model.$.propertyValue, () => model.loanType === 'mortgage', { resetOnDisable: true });
@@ -38,7 +38,7 @@ export declare function enableWhen(target: ReadonlySignal<unknown>, condition: (
  * сигнал→нода и вызывает `disable()`, когда `condition` истинно (+`reset()` при `resetOnDisable`).
  * `condition` реактивен (читает свои сигналы модели).
  *
- * @group Model
+ * @group Form
  * @param target Сигнал-цель поля (`model.$.<path>`).
  * @param condition Реактивное условие; при `true` поле выключается.
  * @param options.resetOnDisable Сбросить значение при выключении (по умолчанию `false`).

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

@@ -0,0 +1,51 @@
+import { Signal, ReadonlySignal } from '@preact/signals-core';
+import { ChangeContext } from './types';
+/** Вычисляемое поле с auto-tracking: `target = read()` при изменении прочитанных сигналов. */
+export declare function compute<R>(target: Signal<R>, read: () => R, options?: {
+    when?: () => boolean;
+}): void;
+/** Вычисляемое поле с явным списком зависимостей (escape hatch). */
+export declare function computeFrom<R>(sources: ReadonlySignal<unknown>[], target: Signal<R>, fn: (...values: any[]) => R, options?: {
+    when?: (...values: any[]) => boolean;
+}): void;
+/** Копирование `source → target` — скаляр или группа (объект целиком). */
+export declare function copyFrom<T>(source: ReadonlySignal<T> | object, target: Signal<T> | object, options?: {
+    when?: () => boolean;
+    transform?: (value: T) => T;
+}): void;
+/**
+ * Реакция на изменение поля; `{ debounce, immediate }`.
+ *
+ * Колбэк выполняется ВНЕ effect-контекста (микротаск/таймер) — можно безопасно писать сигналы и ноды
+ * (`updateComponentProps`/`reset`/`clear`) без ручного `defer` и без «Cycle detected».
+ *
+ * Для async-колбэков 2-м аргументом приходит `{ signal }` (AbortSignal): при следующей смене значения
+ * предыдущий `signal` аннулируется. Передавай его в `fetch` (сетевая отмена) или проверяй
+ * `signal.aborted` перед применением результата — это убирает гонки устаревших ответов (F2).
+ */
+export declare function onChange<T>(source: ReadonlySignal<T>, cb: (value: T, ctx: ChangeContext) => void, options?: {
+    immediate?: boolean;
+    debounce?: number;
+}): void;
+type EnableTarget = ReadonlySignal<unknown> | object;
+/** Условное включение поля(ей) — скаляр, массив целей или группа. `resetOnDisable=false` по умолчанию. */
+export declare function enableWhen(target: EnableTarget | EnableTarget[], condition: () => boolean, options?: {
+    resetOnDisable?: boolean;
+}): void;
+/** Условное выключение поля(ей) (инверсия {@link enableWhen}). */
+export declare function disableWhen(target: EnableTarget | EnableTarget[], condition: () => boolean, options?: {
+    resetOnDisable?: boolean;
+}): void;
+/** Трансформация значения поля (идемпотентная). */
+export declare function transformValue<T>(target: Signal<T>, transformer: (value: T) => T): void;
+/** Сброс значения по условию. */
+export declare function resetWhen<T>(target: Signal<T>, condition: () => boolean, options?: {
+    resetValue?: T;
+}): void;
+/** Двусторонняя синхронизация двух полей. */
+export declare function syncFields<T>(a: Signal<T>, b: Signal<T>, options?: {
+    transform?: (value: T) => T;
+}): void;
+/** Ревалидация при изменении зависимостей. */
+export declare function revalidateWhen(deps: ReadonlySignal<unknown>[], revalidate: () => void): void;
+export {};

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

@@ -0,0 +1,17 @@
+import { Signal, ReadonlySignal } from '@preact/signals-core';
+import { BehaviorCleanup, FormModel, FormProxy } from '../../index';
+/** Контекст схемы поведения: модель (значения/сигналы) + форма (ноды). */
+export type BehaviorScope<T> = {
+    model: FormModel<T>;
+    form: FormProxy<T>;
+};
+/** Результат {@link defineFormBehavior}; передаётся в `createForm({ behavior })`. */
+export interface FormBehavior<T> {
+    /** @internal Запускается `createForm` после построения нод и заполнения реестра сигнал→нода. */
+    __run(model: FormModel<T>, form: FormProxy<T>): BehaviorCleanup;
+}
+export type { Signal, ReadonlySignal, BehaviorCleanup };
+/** Контекст async-реакции: `signal` аннулируется, когда поле меняется снова до завершения колбэка. */
+export interface ChangeContext {
+    signal: AbortSignal;
+}

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

@@ -1,9 +1,9 @@
-import { FormModel } from '../state/types';
+import { FormModel } from '../model/types';
 import { FormSchemaNode } from './types/schema-node';
 import { FormBehavior } from './behaviors';
 import { FormProxy } from './types/index';
-import { FormValidation, FormValidationBundle } from './validation-config';
-import { ValidationSchema } from './validation-schema';
+import { FormValidation, FormValidationBundle } from './validation/config';
+import { ValidationSchema } from './validation';
 /**
  * Общая часть конфига всех фабрик формы.
  *

package/dist/form/create-form.d.ts

@@ -1,10 +1,10 @@
 import { FormProxy, GroupNodeConfig, FormSchema } from './types/index';
 import { FormSchemaNode } from './types/schema-node';
-import { FormModel } from '../state/types';
+import { FormModel } from '../model/types';
 import { FormBehavior } from './behaviors';
 /**
  * Аргументы createForm под архитектуру M1: данные приходят из {@link FormModel},
- * конфиг полей (component/componentProps/validators) — из единой схемы.
+ * конфиг полей (component/componentProps) — из единой схемы.
  *
  * @group Utilities
  */
@@ -27,7 +27,7 @@ export interface CreateFormFromModelArgs<T> {
  *
  * Значения принадлежат модели (источник истины), ноды формы держат UI/валидационное состояние и
  * ссылаются на сигналы модели по идентичности (`node.value === model.$.path`). Обходит структуру
- * модели, привязывает конфиг поля (component/componentProps/validators) из схемы, материализует
+ * модели, привязывает конфиг поля (component/componentProps) из схемы, материализует
  * top-level массивы как {@link ModelArrayNode}, заполняет реестр сигнал→нода (для `enableWhen`/
  * роутинга ошибок) и, при наличии, запускает декларативное поведение (cleanup живёт на форме).
  *
@@ -51,9 +51,10 @@ export interface CreateFormFromModelArgs<T> {
  * const schema = {
  *   component: Section,
  *   children: [
- *     { value: model.$.email, component: Input, validators: [required] },
+ *     // Layout несёт только component/componentProps; правила — в отдельной ValidationSchema.
+ *     { value: model.$.email, component: InputField },
  *     // вложенная группа: `model.$.profile.name` (≡ под-модель `model.profile.$.name` — тот же сигнал)
- *     { value: model.$.profile.name, component: Input },
+ *     { value: model.$.profile.name, component: InputField },
  *   ],
  * };
  *
@@ -92,8 +93,8 @@ export declare function createFormFromModel<T>(args: CreateFormFromModelArgs<T>)
  * // Layout-схема НЕ несёт validators — только component/componentProps.
  * const schema = {
  *   children: [
- *     { value: model.$.email, component: Input },
- *     { value: model.$.password, component: Input },
+ *     { value: model.$.email, component: InputField },
+ *     { value: model.$.password, component: InputField },
  *   ],
  * };
  *
@@ -115,7 +116,8 @@ export declare function createForm<T>(config: GroupNodeConfig<T>): FormProxy<T>;
  *
  * @deprecated Legacy / back-compat: плоская `FormSchema` с инлайн-значениями (`value: ''`) — путь
  *   ДО архитектуры M1. Для нового кода используйте перегрузку `createForm({ model, schema })`
- *   (значения принадлежат {@link FormModel}, валидаторы — фабрики в `validators: [...]`).
+ *   (значения принадлежат {@link FormModel}, а правила — отдельной схеме `defineValidationSchema`,
+ *   которую прогоняет `validateModel`; поля `validators` у узла layout-схемы нет).
  *
  * @param schema - Схема полей формы
  * @returns Типизированная форма с Proxy-доступом к полям
@@ -123,8 +125,8 @@ export declare function createForm<T>(config: GroupNodeConfig<T>): FormProxy<T>;
  * @example Legacy (back-compat) — плоская схема без модели
  * ```typescript
  * const form = createForm<UserForm>({
- *   email: { value: '', component: Input },
- *   password: { value: '', component: Input },
+ *   email: { value: '', component: InputField },
+ *   password: { value: '', component: InputField },
  * });
  * ```
  */