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

package/dist/create-model-BvcbNPgL.js

@@ -0,0 +1,30 @@
+import { M as f, j as c, k as r, l } from "./safe-effect-BbtX3KuN.js";
+function n(o, e, a) {
+  if (o.kind === "leaf") {
+    e(o.signal);
+    return;
+  }
+  if (o.kind === "group") {
+    for (const t of o.children.values()) n(t, e, a);
+    return;
+  }
+  a && e(l(o));
+  for (const t of o.items.value) n(t, e, a);
+}
+function u(o, e) {
+  const a = r.get(o);
+  a && n(a, e, !1);
+}
+function i(o, e) {
+  const a = r.get(o);
+  a && n(a, e, !0);
+}
+function g(o) {
+  const e = new f(o, "");
+  return c(e);
+}
+export {
+  i as a,
+  g as c,
+  u as e
+};

package/dist/date-utils-90-qZbse.js

@@ -0,0 +1,43 @@
+const a = /^(\d{4})-(\d{2})-(\d{2})$/;
+function g(t) {
+  if (t == null || t === "")
+    return null;
+  if (t instanceof Date)
+    return isNaN(t.getTime()) ? null : t;
+  if (typeof t == "string") {
+    const e = a.exec(t);
+    return e ? l(Number(e[1]), Number(e[2]) - 1, Number(e[3])) : null;
+  }
+  return null;
+}
+function l(t, e, r) {
+  const n = /* @__PURE__ */ new Date(0);
+  return n.setFullYear(t, e, r), n.setHours(0, 0, 0, 0), n.getFullYear() === t && n.getMonth() === e && n.getDate() === r ? n : null;
+}
+function i() {
+  const t = /* @__PURE__ */ new Date();
+  return t.setHours(0, 0, 0, 0), t;
+}
+function u(t) {
+  const e = new Date(t);
+  return e.setHours(0, 0, 0, 0), e;
+}
+const c = (t) => t % 4 === 0 && t % 100 !== 0 || t % 400 === 0;
+function f(t) {
+  return u(t) > i();
+}
+function D(t) {
+  const e = i(), r = u(t);
+  let n = r.getDate();
+  r.getMonth() === 1 && n === 29 && !c(e.getFullYear()) && (n = 28);
+  let o = e.getFullYear() - r.getFullYear();
+  const s = e.getMonth() - r.getMonth();
+  return (s < 0 || s === 0 && e.getDate() < n) && (o -= 1), o;
+}
+export {
+  D as c,
+  i as g,
+  f as i,
+  u as n,
+  g as p
+};

package/dist/{en-CjAqn7h0.js → en-HP8XEych.js}

@@ -1,4 +1,4 @@
-const a = {
+const e = {
   "format.fileSize.b": "{value} B",
   "format.fileSize.kb": "{value} KB",
   "format.fileSize.mb": "{value} MB",
@@ -14,6 +14,8 @@ const a = {
   "validation.max": "Must be at most {max}",
   "validation.minLength": "Enter at least {minLength, plural, one{# character} other{# characters}}",
   "validation.maxLength": "Enter no more than {maxLength, plural, one{# character} other{# characters}}",
+  "validation.minItems": "At least {minLength, plural, one{# item} other{# items}}",
+  "validation.maxItems": "No more than {maxLength, plural, one{# item} other{# items}}",
   "validation.isNumber": "Enter a number",
   "validation.integer": "Enter a whole number",
   "validation.multipleOf": "Must be a multiple of {multipleOf}",
@@ -34,8 +36,9 @@ const a = {
   "validation.maxTotalFileSize": "The total size of the files exceeds {maxTotalFileSize}",
   "validation.fileExists": "File {fileName} has already been added",
   "validation.uploadAborted": "Upload cancelled",
-  "validation.uploadFailed": "Failed to upload {fileName}"
+  "validation.uploadFailed": "Failed to upload {fileName}",
+  "validation.ruleFailed": "Could not check this field. Try again"
 };
 export {
-  a as m
+  e as m
 };

package/dist/form/aggregate-signals.d.ts

@@ -1,71 +1,29 @@
-import { ReadonlySignal, Signal } from '@preact/signals-core';
-import { FieldStatus, ValidationError } from './types/index';
-import { FormNode } from './nodes/form-node';
-/**
- * Функция получения дочерних узлов
- * Возвращает массив FormNode для агрегации состояния
- */
-type GetChildrenFn<T> = () => FormNode<T>[];
-/**
- * Результат создания агрегированных сигналов
- */
+import { ReadonlySignal } from '@preact/signals-core';
+import { ValidationIssue } from './types/contracts';
+import { FormNode } from './types/nodes';
 export interface AggregateSignals {
-    /** Все дочерние узлы валидны и нет собственных ошибок */
+    /**
+     * Контейнер включён, блокирующих своих замечаний нет, никто не ждёт проверки, каждый включённый
+     * ребёнок валиден.
+     */
     valid: ReadonlySignal<boolean>;
-    /** Есть ошибки (инверсия valid) */
+    /** Никто не ждёт проверки, и есть блокирующее своё замечание или включённый невалидный ребёнок. */
     invalid: ReadonlySignal<boolean>;
-    /** Хотя бы один дочерний узел в состоянии pending */
+    /** Контейнер или хотя бы один ребёнок ждёт проверки. */
     pending: ReadonlySignal<boolean>;
-    /** Хотя бы один дочерний узел touched */
     touched: ReadonlySignal<boolean>;
-    /** Хотя бы один дочерний узел dirty */
     dirty: ReadonlySignal<boolean>;
-    /** Собственные ошибки + ошибки всех дочерних узлов */
-    errors: ReadonlySignal<ValidationError[]>;
-    /** Статус: disabled > pending > invalid > valid */
-    status: ReadonlySignal<FieldStatus>;
+    /** Свои замечания и замечания всех детей. */
+    issues: ReadonlySignal<readonly ValidationIssue[]>;
 }
-/**
- * Опции для создания агрегированных сигналов
- */
-export interface AggregateSignalsOptions<T> {
-    /** Функция получения дочерних узлов */
-    getChildren: GetChildrenFn<T>;
-    /** Signal с собственными ошибками контейнера (form-level или array-level) */
-    ownErrors: Signal<ValidationError[]>;
-    /** Опциональный signal disabled состояния (для GroupNode) */
-    disabled?: Signal<boolean>;
+export interface AggregateSignalsOptions {
+    /** Дети контейнера; чтение внутри `computed` подписывает на их состав. */
+    getChildren: () => readonly FormNode<unknown>[];
+    /** Замечания самого контейнера. */
+    ownIssues: ReadonlySignal<readonly ValidationIssue[]>;
+    /** Ожидание async-правила на ручке самого контейнера (`validateAsync(model.$.items, …)`). */
+    ownPending?: ReadonlySignal<boolean>;
+    /** Выключен ли сам контейнер: выключенный — ни `valid`, ни `invalid`, ни `pending`, как поле. */
+    disabled?: ReadonlySignal<boolean>;
 }
-/**
- * Создать агрегированные computed signals для контейнерного узла
- *
- * Используется в GroupNode и ArrayNode для унификации логики
- * вычисления состояния на основе дочерних узлов.
- *
- * @param options - Опции конфигурации
- * @returns Объект с computed signals
- *
- * @example GroupNode
- * ```typescript
- * const signals = createAggregateSignals({
- *   getChildren: () => Array.from(this._fields.values()),
- *   ownErrors: this._formErrors,
- *   disabled: this._disabled,
- * });
- * this.valid = signals.valid;
- * this.invalid = signals.invalid;
- * // ...
- * ```
- *
- * @example ArrayNode
- * ```typescript
- * const signals = createAggregateSignals({
- *   getChildren: () => this.items.value,
- *   ownErrors: this._arrayErrors,
- * });
- * this.valid = signals.valid;
- * // ...
- * ```
- */
-export declare function createAggregateSignals<T>(options: AggregateSignalsOptions<T>): AggregateSignals;
-export {};
+export declare function createAggregateSignals(options: AggregateSignalsOptions): AggregateSignals;

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

@@ -1,6 +1,22 @@
 import { Signal } from '@preact/signals-core';
-import { FormModel } from '../../index';
+import { FormModel, ModelArray } from '../../model/types';
 import { FormBehavior } from './types';
+/**
+ * Ручка массива под-форм `model.$.<массив>`. Тип строки выводится из её `peek()` — так же, как у
+ * `applyEach` валидации. Раньше цель была `object`: тип строки не выводился (`unknown`), а чужая
+ * схема строки и ручка не того вида проходили компиляцию.
+ */
+interface ArrayHandle<TItem> {
+    peek(): readonly TItem[] | null | undefined;
+}
+/** Цель операторов массива: ручка `model.$.<массив>` либо его value-фасад `model.<массив>`. */
+type ArrayTarget<TItem> = ArrayHandle<TItem> | ModelArray<TItem>;
+/** Ручка группы `model.$.<группа>`: тип значения — из её `peek()`. */
+interface GroupHandle<V> {
+    peek(): V;
+}
+/** Цель `apply`: ручка `model.$.<группа>` либо её value-фасад `model.<группа>`. */
+type GroupTarget<V> = GroupHandle<V> | FormModel<NonNullable<V>>;
 /**
  * Применить под-схему к КАЖДОМУ элементу динамического массива (per-item поведение).
  * Реагирует на добавление/удаление строк: новым строкам поведение применяется, удалённым — отписывается.
@@ -8,26 +24,34 @@ import { FormBehavior } from './types';
  * Под-схема получает scope строки: `model` (под-модель строки — `row.$.field`) и `form` (нода строки).
  * - Value-операции (`compute`/`copyFrom`/`transformValue` на `row.$.*`) работают всегда.
  * - Node-операции (`enableWhen`/`updateComponentProps`/`reset` через `form.*`) требуют, чтобы массив был
- *   МАТЕРИАЛИЗОВАН в форме (узел `{ array, item }` в схеме) — тогда `form` строки = та же нода, что
+ *   МАТЕРИАЛИЗОВАН в форме (узел `{ model: model.$.<массив>, item }` в схеме) — тогда `form` строки = та же нода, что
  *   рендерится, а её сигналы зарегистрированы (`enableWhen` резолвит ноду). Без материализации доступ
  *   к `form.*` бросит понятную ошибку (см. {@link unmaterializedRowForm}).
  *
+ * Работает на любой глубине: массив в корне, в группе и в строке другого массива — в схеме строки
+ * можно снова вызвать `applyEach`.
+ *
  * @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 — нужна материализация массива
+ *   applyEach(row.$.phones, phoneBehavior);                  // массив внутри строки
  * }));
  */
-export declare function applyEach<TItem>(array: object, itemSchema: FormBehavior<TItem>): void;
+export declare function applyEach<TItem extends object>(array: ArrayTarget<TItem>, itemSchema: FormBehavior<NoInfer<TItem>>): void;
 /**
  * Взаимное исключение булева флага среди строк массива (single-selection — «единственный primary»).
  * Когда флаг строки становится true, у остальных строк он сбрасывается в false. Не хрупок к push:
  * новые строки с флагом false исключения не запускают.
  *
+ * Начальные данные и добавленные строки флаг не МЕНЯЮТ — он приходит сразу `true`. Такая строка
+ * прежний выбор не снимает: флаг сбрасывается у неё. Из нескольких пришедших с `true` сразу
+ * (начальные данные) остаётся первая по порядку строк.
+ *
  * @example
  * exclusiveFlag(model.$.contacts, (row) => row.$.primary);
  */
-export declare function exclusiveFlag<TItem>(array: object, getFlag: (row: FormModel<TItem>) => Signal<boolean>): void;
+export declare function exclusiveFlag<TItem extends object>(array: ArrayTarget<TItem>, getFlag: (row: FormModel<NoInfer<TItem>>) => Signal<boolean>): void;
 /**
  * Агрегатная запись в строки массива. `derive(snapshot)` получает СНИМОК строк и возвращает список
  * `{ index, patch }`, который применяется к строкам. Записи КОАЛЕСИРУЮТСЯ в один отложенный проход на
@@ -42,9 +66,19 @@ export declare function exclusiveFlag<TItem>(array: object, getFlag: (row: FormM
  *   return [{ index: n - 1, patch: { percent: 100 - others } }];
  * });
  */
-export declare function aggregateInto<TItem>(array: object, derive: (rows: TItem[]) => Array<{
+export declare function aggregateInto<TItem extends object>(array: ArrayTarget<TItem>, derive: (rows: NoInfer<TItem>[]) => Array<{
     index: number;
-    patch: Partial<TItem>;
+    patch: Partial<NoInfer<TItem>>;
 }>): void;
-/** Применить под-схему к одному или нескольким полям-группам (переиспользование). */
-export declare function apply<TField>(targets: object | object[], subSchema: FormBehavior<TField>): void;
+/**
+ * Применить под-схему к одному или нескольким полям-группам (переиспользование).
+ *
+ * Под-схема получает scope группы: `model` — настоящая под-модель (`model.$.field`, чтение и
+ * запись значений, `get`/`set`/`patch`), `form` — нода группы. Цель — ручка группы
+ * (`model.$.address`); работает и в корневой схеме, и в схеме строки массива.
+ *
+ * @example
+ * apply([model.$.registrationAddress, model.$.residenceAddress], addressBehavior);
+ */
+export declare function apply<V extends object | null | undefined>(targets: GroupTarget<V> | GroupTarget<V>[], subSchema: FormBehavior<NoInfer<NonNullable<V>>>): void;
+export {};

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

@@ -1,23 +1,56 @@
-import { BehaviorCleanup } from '../../index';
+import { BehaviorCleanup } from '../../model/behaviors-value';
+import { SchemaController } from '../schema-controller';
 import { BehaviorScope, FormBehavior } from './types';
+import { FormFlow } from '../flow/flow';
 /** Зарегистрировать произвольную отписку в активной схеме. */
 export declare function onDispose(cleanup: BehaviorCleanup): void;
-/** Текущий scope ({ model, form }) активной схемы (escape hatch для кросс-операторов). */
+/**
+ * Оператор вызван внутри схемы поведения? Иначе — понятная ошибка с именем оператора ДО любых
+ * побочных эффектов: effect, созданный до проверки, остался бы жить, а признак derived — висеть.
+ *
+ * @internal
+ */
+export declare function assertInsideSchema(op: string): void;
+/**
+ * Зарегистрировать отписку, если оператор вызван внутри схемы поведения; вне схемы — ничего.
+ * Для операторов, которые работают и сами по себе (правила узлов схемы).
+ *
+ * @internal
+ */
+export declare function onDisposeIfActive(cleanup: BehaviorCleanup): void;
+/** Текущая область ({ model, form, schema }) активной схемы (escape hatch для кросс-операторов). */
 export declare function getScope<T>(): BehaviorScope<T>;
+/**
+ * Схема-контроллер сборки, в которой идёт активная схема: под-схемы (`apply`, `applyEach`)
+ * получают через него область своей под-модели.
+ *
+ * @internal
+ */
+export declare function getController(op?: string): SchemaController;
+/**
+ * Поток шагов текущего прогона схемы — его получают поведения подформ и строк массива.
+ *
+ * @internal
+ */
+export declare function getFlow(op?: string): FormFlow | undefined;
 /**
  * Описать поведение формы декларативно. Возвращает {@link FormBehavior} для `createForm({ behavior })`.
  *
  * @example
  * ```ts
- * export const myBehavior = defineFormBehavior<MyForm>(({ model, form }) => {
+ * export const myBehavior = defineFormBehavior<MyForm>(({ model, form, schema }) => {
  *   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) }));
+ *   hideWhen(schema.node('delivery'), () => model.country === '');
  * });
  * ```
  */
 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». */
+/**
+ * Отложенная запись вне effect-контекста (микротаск) — защита от «Cycle detected». Внутри схемы
+ * поведения (в `setup`, в её effect'ах и отложенных заданиях) запись отменяется снятием схемы.
+ */
 export declare function defer(fn: () => void): void;

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

@@ -2,16 +2,16 @@
  * Декларативный контракт схемы поведения формы — `@reformer/core/behaviors`.
  *
  * Свободные операторы (`compute`/`copyFrom`/`enableWhen`/`onChange`/…) вызываются внутри
- * `defineFormBehavior(({ model, form }) => { … })` и САМИ регистрируют свои отписки в ambient-стоке —
+ * `defineFormBehavior(({ model, form, schema }) => { … })` и САМИ регистрируют свои отписки в ambient-стоке —
  * автор схемы не видит ни массива `cleanups`, ни `.push`, ни вызовов через точку. Жизненным циклом
  * владеет форма (`createForm({ behavior })`). Операторы — тонкие обёртки над примитивами слоя данных
  * ({@link module:model/behaviors-value}); пользовательские операторы пишутся так же и неотличимы от встроенных.
  *
  * Граница ответственности: контракт НЕ управляет валидацией — это отдельный слой
- * (`defineValidationSchema` + раннер `validateModel` из `@reformer/core/validation`), он остаётся
- * владельцем `errors`. Это сделано намеренно. Для редких крайних случаев
+ * (`defineValidation` + раннер `validateModel` из `@reformer/core/validation`), он остаётся
+ * владельцем `issues`. Это сделано намеренно. Для редких крайних случаев
  * behavior-driven валидации (cross-field, async-uniqueness) можно написать собственный оператор поверх
- * `effect`/`onChange` + `node.setErrors(...)` — он будет неотличим от встроенного; примеры см. в
+ * `effect`/`onChange` + `node.setIssues(...)` — он будет неотличим от встроенного; примеры см. в
  * tests/behaviors/web-scenarios (W1/W3). В общем случае правила валидности держите в слое валидации.
  *
  * Модуль разложен по зонам ответственности: `./types` — контракт схемы, `./context` — ambient-сток
@@ -26,3 +26,5 @@ 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';
+export { hideWhen, onComponentEvent, renderEffect, onInit, onMount, onUnmount, } from './schema-operators';
+export type { SchemaScope, SchemaNodeControl } from '../schema-controller';

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

@@ -24,12 +24,18 @@ export declare const isLeafSignal: (v: unknown) => v is Signal<unknown>;
 export declare const isValueHandle: (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 (без
+ * Запись значения в группу — как полная установка `model.<группа>.set(...)`: поля цели, которых в
+ * значении нет, остаются прежними, а не стираются. Их пути (относительно группы) складываются в
+ * `missing` — по ним вызывающий предупреждает в dev. Значение не объект — группа не тронута.
+ *
+ * @param at - Путь текущей группы относительно корня записи (для `missing`).
+ */
+export declare function writeGroup(g: GroupSignals, val: Record<string, unknown>, missing?: string[], at?: string): void;
+/**
+ * Guard от расходящихся циклов пересчёта. Расходящийся взаимный 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

@@ -1,11 +1,34 @@
 import { ReadonlySignal } from '@preact/signals-core';
 import { BehaviorCleanup } from '../../model/behaviors-value';
+/** Нода формы, чьей доступностью управляет оператор: поле, группа или массив под-форм. */
+export interface AvailabilityTarget {
+    enable(): void;
+    disable(): void;
+}
+/**
+ * Отложенное применение доступности ноды по условию.
+ *
+ * Решение принимается в момент записи, а новое задание отменяет ожидающее (побеждает последнее):
+ * иначе задание «выключить и стереть» первого прогона выполнилось бы после загрузки данных в том же
+ * тике и стёрло их, хотя поле к этому моменту уже снова доступно. Снятие отменяет ожидающее
+ * задание — запись после dispose не случится.
+ *
+ * @internal
+ */
+export declare function availabilityWrites(condition: () => boolean, options?: {
+    resetOnDisable?: boolean;
+}): {
+    schedule(node: AvailabilityTarget): void;
+    cancel(): void;
+};
 /**
  * Условное включение поля (state-операция). Резолвит ноду по сигналу-цели через реестр
  * сигнал→нода (заполняется `createForm`) и вызывает `enable()`/`disable()` (+`reset()` при
  * `resetOnDisable`). `condition` реактивен (читает свои сигналы модели).
  *
- * Запись состояния отложена через `runOutsideEffect` (микротаск) для защиты от «Cycle detected».
+ * Запись состояния отложена на микротаск для защиты от «Cycle detected». Условие читается в момент
+ * записи, и побеждает последнее решение: загрузка данных в том же тике, что и сборка, не стирается
+ * заданием первого прогона. Снятие отменяет ещё не выполненную запись.
  * ⚠️ Поле должно быть материализовано в форме (`createForm`) — иначе ноды в реестре нет (например,
  * элемент массива, который строится per-item).
  *
@@ -14,7 +37,7 @@ import { BehaviorCleanup } from '../../model/behaviors-value';
  * работает со статус-машиной ноды (enable/disable/reset), а `compute` пишет `target.value` напрямую
  * в сигнал модели и проверяет только собственный `options.when` — состояние `disabled` он НЕ смотрит.
  * Поэтому при выключенном поле любое изменение зависимости compute молча заново заполнит его (а с
- * `resetOnDisable` — перезапишет только что сброшенное значение), и так как `getValue()`/`submit`
+ * `resetOnDisable` — перезапишет только что сброшенное значение), и так как `getValue()` и отправка
  * включают disabled-поля, мусор утечёт в payload. Это аналог правила #13 гайда add-behavior,
  * которое сегодня сформулировано только для `copyFrom`; для `compute` то же ограничение обязательно.
  *

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

@@ -1,14 +1,21 @@
 import { Signal, ReadonlySignal } from '@preact/signals-core';
+import { ResetWhenOptionsArg } from '../../model/behaviors-value';
 import { ChangeContext } from './types';
 /** Вычисляемое поле с auto-tracking: `target = read()` при изменении прочитанных сигналов. */
-export declare function compute<R>(target: Signal<R>, read: () => R, options?: {
+export declare function compute<R>(target: Signal<R>, read: () => NoInfer<R>, options?: {
     when?: () => boolean;
 }): void;
 /** Вычисляемое поле с явным списком зависимостей (escape hatch). */
-export declare function computeFrom<R>(sources: ReadonlySignal<unknown>[], target: Signal<R>, fn: (...values: any[]) => R, options?: {
+export declare function computeFrom<R>(sources: ReadonlySignal<unknown>[], target: Signal<R>, fn: (...values: any[]) => NoInfer<R>, options?: {
     when?: (...values: any[]) => boolean;
 }): void;
-/** Копирование `source → target` — скаляр или группа (объект целиком). */
+/**
+ * Копирование `source → target` — скаляр или группа (объект целиком).
+ *
+ * Группы разной формы копируются как `set` группы модели: поля цели, которых нет в значении,
+ * остаются прежними; в dev об этом одно предупреждение на оператор. Значение цели целиком
+ * собирает `transform`.
+ */
 export declare function copyFrom<T>(source: ReadonlySignal<T> | object, target: Signal<T> | object, options?: {
     when?: () => boolean;
     transform?: (value: T) => T;
@@ -21,7 +28,7 @@ export declare function copyFrom<T>(source: ReadonlySignal<T> | object, target:
  *
  * Для async-колбэков 2-м аргументом приходит `{ signal }` (AbortSignal): при следующей смене значения
  * предыдущий `signal` аннулируется. Передавай его в `fetch` (сетевая отмена) или проверяй
- * `signal.aborted` перед применением результата — это убирает гонки устаревших ответов (F2).
+ * `signal.aborted` перед применением результата — это убирает гонки устаревших ответов.
  */
 export declare function onChange<T>(source: ReadonlySignal<T>, cb: (value: T, ctx: ChangeContext) => void, options?: {
     immediate?: boolean;
@@ -38,12 +45,13 @@ export declare function disableWhen(target: EnableTarget | EnableTarget[], condi
 }): 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;
+/**
+ * Сброс значения по условию. Без `resetValue` поле сбрасывается в `null` — поэтому полю, в тип
+ * которого `null` не входит, `resetValue` обязателен (см. {@link ResetWhenOptionsArg}).
+ */
+export declare function resetWhen<T>(target: Signal<T>, condition: () => boolean, ...options: ResetWhenOptionsArg<T>): void;
 /** Двусторонняя синхронизация двух полей. */
-export declare function syncFields<T>(a: Signal<T>, b: Signal<T>, options?: {
+export declare function syncFields<T>(a: Signal<T>, b: Signal<NoInfer<T>>, options?: {
     transform?: (value: T) => T;
 }): void;
 /** Ревалидация при изменении зависимостей. */

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

@@ -0,0 +1,78 @@
+import { SchemaNodeControl, SchemaScope } from '../schema-controller';
+/**
+ * Скрывать узел, пока условие истинно.
+ *
+ * Условие реактивно: пересчитывается при изменении любого сигнала, прочитанного внутри него.
+ * Принудительное `schema.node(selector).setHidden(...)` главнее условия.
+ *
+ * @example
+ * ```typescript
+ * hideWhen(schema.node('mortgage'), () => model.loanType !== 'mortgage');
+ * ```
+ */
+export declare function hideWhen(node: SchemaNodeControl, condition: () => boolean): void;
+/**
+ * Повесить обработчик на проп-событие компонента узла (`onSubmit`, `onChange`, …).
+ *
+ * Обработчик получает те же аргументы, что и исходный проп компонента. У контейнера он перекрывает
+ * одноимённый проп из `componentProps`. У поля и массива событие уже занято привязкой (запись
+ * значения в форму, кнопки массива) — обработчик вызывается после неё, а не вместо: ввод не ломается.
+ * У подформы своего компонента нет — правило не действует, в dev рендерер предупреждает.
+ *
+ * @example
+ * ```typescript
+ * onComponentEvent(schema.node('wizard'), 'onSubmit', async () => {
+ *   await submitApplication(model.get());
+ * });
+ * ```
+ */
+export declare function onComponentEvent(node: SchemaNodeControl, event: string, handler: (...args: any[]) => any): void;
+/**
+ * Реактивный эффект, живущий, пока схема области смонтирована рендерером.
+ *
+ * В отличие от `effect` поведения, запускается после монтирования — внутри доступны ref узлов
+ * (`schema.node(selector).getRef().current`). Может вернуть функцию очистки.
+ *
+ * @example
+ * ```typescript
+ * const panel = schema.node('summary').getRef<HTMLElement>();
+ * renderEffect(schema, () => {
+ *   if (model.loanType === 'mortgage') panel.current?.scrollIntoView();
+ * });
+ * ```
+ */
+export declare function renderEffect(schema: SchemaScope, effectFn: () => void | (() => void)): void;
+/**
+ * Синхронный хук времени сборки: `fn` вызывается сразу, до первого рендера узла. Единственный
+ * хук, способный повлиять на первый рендер, — внутри можно править пропсы через
+ * `schema.node(selector).patchProps({ … })`.
+ *
+ * К монтированию узла не привязан; аргумент `node` принимается ради симметрии с
+ * {@link onMount} / {@link onUnmount}.
+ *
+ * @example
+ * ```typescript
+ * onInit(schema.node('summary'), () => {
+ *   schema.node('summary').patchProps({ currency: detectCurrency() });
+ * });
+ * ```
+ */
+export declare function onInit(_node: SchemaNodeControl, fn: () => void): void;
+/**
+ * Хук после первого монтирования узла. Может вернуть очистку — она выполнится при размонтировании.
+ *
+ * @example
+ * ```typescript
+ * onMount(schema.node('data-boundary'), () => void loadApplication());
+ * ```
+ */
+export declare function onMount(node: SchemaNodeControl, fn: () => void | (() => void)): void;
+/**
+ * Хук перед размонтированием узла.
+ *
+ * @example
+ * ```typescript
+ * onUnmount(schema.node('wizard'), () => saveDraft(model.get()));
+ * ```
+ */
+export declare function onUnmount(node: SchemaNodeControl, fn: () => void): void;

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

@@ -1,14 +1,34 @@
 import { Signal, ReadonlySignal } from '@preact/signals-core';
-import { BehaviorCleanup, FormModel, FormProxy } from '../../index';
-/** Контекст схемы поведения: модель (значения/сигналы) + форма (ноды). */
+import { BehaviorCleanup } from '../../model/behaviors-value';
+import { FormModel } from '../../model/types';
+import { FormGroup } from '../types/index';
+import { SchemaController, SchemaScope } from '../schema-controller';
+import { FormFlow } from '../flow/flow';
+/**
+ * Область схемы поведения: модель (значения и сигналы), форма (ноды) и схема (узлы разметки).
+ *
+ * `schema` адресует узлы СВОЕЙ области: в корневом поведении — корневое дерево, в поведении
+ * подформы (`apply`) и строки массива (`applyEach`) — поддерево этой части. Правила узлов
+ * (`hideWhen`, `onComponentEvent`, `onMount`) исполняет рендерер; без него они ничего не делают.
+ */
 export type BehaviorScope<T> = {
     model: FormModel<T>;
-    form: FormProxy<T>;
+    form: FormGroup<T>;
+    schema: SchemaScope;
+    /**
+     * Поток шагов сборки (`createForm({ flow })`); без потока — `undefined`. Один на сборку: его
+     * же получают поведения подформ и строк массива.
+     */
+    flow: FormFlow | undefined;
 };
 /** Результат {@link defineFormBehavior}; передаётся в `createForm({ behavior })`. */
 export interface FormBehavior<T> {
-    /** @internal Запускается `createForm` после построения нод и заполнения реестра сигнал→нода. */
-    __run(model: FormModel<T>, form: FormProxy<T>): BehaviorCleanup;
+    /**
+     * @internal Запускается сборкой формы после построения нод и заполнения реестра сигнал→нода.
+     * `controller` — схема-контроллер сборки; без него поведение получает собственный, который
+     * никто не читает (модель без рендерера). `flow` — поток шагов сборки.
+     */
+    __run(model: FormModel<T>, form: FormGroup<T>, controller?: SchemaController, flow?: FormFlow): BehaviorCleanup;
 }
 export type { Signal, ReadonlySignal, BehaviorCleanup };
 /** Контекст async-реакции: `signal` аннулируется, когда поле меняется снова до завершения колбэка. */