@reformer/core 10.2.0 → 11.0.0-beta.10

package/dist/create-model-DPSG3I0O.js

@@ -0,0 +1,30 @@
+import { M as f, j as c, k as r, l } from "./safe-effect-BazLOv1g.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-HP8XEych.js

@@ -0,0 +1,44 @@
+const e = {
+  "format.fileSize.b": "{value} B",
+  "format.fileSize.kb": "{value} KB",
+  "format.fileSize.mb": "{value} MB",
+  "format.fileSize.gb": "{value} GB",
+  "format.fileSize.tb": "{value} TB",
+  "validation.required": "This field is required",
+  "validation.pattern": "Invalid format",
+  "validation.email": "Enter a valid email address",
+  "validation.url": "Enter a valid URL",
+  "validation.url_protocol": "The URL must use one of these protocols: {allowedProtocols}",
+  "validation.phone": "Enter a valid phone number",
+  "validation.min": "Must be at least {min}",
+  "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}",
+  "validation.nonNegative": "Must not be negative",
+  "validation.nonZero": "Must not be zero",
+  "validation.date_invalid": "Enter a valid date",
+  "validation.date_min": "The date must not be earlier than {minDate}",
+  "validation.date_max": "The date must not be later than {maxDate}",
+  "validation.date_past": "The date must not be in the past",
+  "validation.date_future": "The date must not be in the future",
+  "validation.date_min_age": "Age must be at least {minAge}",
+  "validation.date_max_age": "Age must be at most {maxAge}",
+  "validation.fileType": "File {fileName} has a type that is not allowed. Allowed: {accept}",
+  "validation.maxFileSize": "File {fileName} is larger than {maxFileSize}",
+  "validation.minFileSize": "File {fileName} is smaller than {minFileSize}",
+  "validation.maxFiles": "No more than {maxFiles, plural, one{# file} other{# files}}",
+  "validation.minFiles": "At least {minFiles, plural, one{# file} other{# files}}",
+  "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.ruleFailed": "Could not check this field. Try again"
+};
+export {
+  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

@@ -0,0 +1,84 @@
+import { Signal } from '@preact/signals-core';
+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 поведение).
+ * Реагирует на добавление/удаление строк: новым строкам поведение применяется, удалённым — отписывается.
+ *
+ * Под-схема получает scope строки: `model` (под-модель строки — `row.$.field`) и `form` (нода строки).
+ * - Value-операции (`compute`/`copyFrom`/`transformValue` на `row.$.*`) работают всегда.
+ * - Node-операции (`enableWhen`/`updateComponentProps`/`reset` через `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 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 extends object>(array: ArrayTarget<TItem>, getFlag: (row: FormModel<NoInfer<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 extends object>(array: ArrayTarget<TItem>, derive: (rows: NoInfer<TItem>[]) => Array<{
+    index: number;
+    patch: Partial<NoInfer<TItem>>;
+}>): 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

@@ -0,0 +1,56 @@
+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;
+/**
+ * Оператор вызван внутри схемы поведения? Иначе — понятная ошибка с именем оператора ДО любых
+ * побочных эффектов: 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, 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». Внутри схемы
+ * поведения (в `setup`, в её effect'ах и отложенных заданиях) запись отменяется снятием схемы.
+ */
+export declare function defer(fn: () => void): void;

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

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

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

@@ -0,0 +1,41 @@
+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>;
+/**
+ * Ручка значения целиком: лист либо узел-массив дерева `$`.
+ *
+ * Массив копируется и читается ЗНАЧЕНИЕМ — заменой целиком, а не обходом по ключам: у его узла
+ * собственный ключ один (`length`), и обход, годный для группы, отдавал бы вместо массива мусор.
+ * Для `enableWhen` массив при этом остаётся НЕ листом ({@link isLeafSignal}): его нода ищется по
+ * пути, а она бывает и полем, и массивом под-форм.
+ */
+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>;
+/**
+ * Запись значения в группу — как полная установка `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;

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

@@ -1,11 +1,34 @@
 import { ReadonlySignal } from '@preact/signals-core';
-import { BehaviorCleanup } from '../state/behaviors-value';
+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,11 +37,11 @@ import { BehaviorCleanup } from '../state/behaviors-value';
  * работает со статус-машиной ноды (enable/disable/reset), а `compute` пишет `target.value` напрямую
  * в сигнал модели и проверяет только собственный `options.when` — состояние `disabled` он НЕ смотрит.
  * Поэтому при выключенном поле любое изменение зависимости compute молча заново заполнит его (а с
- * `resetOnDisable` — перезапишет только что сброшенное значение), и так как `getValue()`/`submit`
+ * `resetOnDisable` — перезапишет только что сброшенное значение), и так как `getValue()` и отправка
  * включают disabled-поля, мусор утечёт в payload. Это аналог правила #13 гайда add-behavior,
  * которое сегодня сформулировано только для `copyFrom`; для `compute` то же ограничение обязательно.
  *
- * @group Model
+ * @group Form
  * @example
  * ```typescript
  * enableWhen(model.$.propertyValue, () => model.loanType === 'mortgage', { resetOnDisable: true });
@@ -38,7 +61,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,59 @@
+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: () => NoInfer<R>, options?: {
+    when?: () => boolean;
+}): void;
+/** Вычисляемое поле с явным списком зависимостей (escape hatch). */
+export declare function computeFrom<R>(sources: ReadonlySignal<unknown>[], target: Signal<R>, fn: (...values: any[]) => NoInfer<R>, options?: {
+    when?: (...values: any[]) => boolean;
+}): void;
+/**
+ * Копирование `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;
+}): void;
+/**
+ * Реакция на изменение поля; `{ debounce, immediate }`.
+ *
+ * Колбэк выполняется ВНЕ effect-контекста (микротаск/таймер) — можно безопасно писать сигналы и ноды
+ * (`updateComponentProps`/`reset`/`clear`) без ручного `defer` и без «Cycle detected».
+ *
+ * Для async-колбэков 2-м аргументом приходит `{ signal }` (AbortSignal): при следующей смене значения
+ * предыдущий `signal` аннулируется. Передавай его в `fetch` (сетевая отмена) или проверяй
+ * `signal.aborted` перед применением результата — это убирает гонки устаревших ответов.
+ */
+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;
+/**
+ * Сброс значения по условию. Без `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<NoInfer<T>>, options?: {
+    transform?: (value: T) => T;
+}): void;
+/** Ревалидация при изменении зависимостей. */
+export declare function revalidateWhen(deps: ReadonlySignal<unknown>[], revalidate: () => void): void;
+export {};

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

@@ -0,0 +1,83 @@
+import { SchemaNodeControl, SchemaScope } from '../schema-controller';
+/**
+ * Скрывать узел, пока условие истинно.
+ *
+ * Условие реактивно: пересчитывается при изменении любого сигнала, прочитанного внутри него.
+ * Принудительное `schema.node(selector).setHidden(...)` главнее условия.
+ *
+ * Только видимость: поля скрытого узла не выключаются и проверяются правилами — переход шага
+ * откажет без замечаний на экране. Поля узла выключай тем же условием через `enableWhen`.
+ *
+ * @example
+ * ```typescript
+ * const mortgage = () => model.loanType === 'mortgage';
+ * enableWhen([model.$.propertyValue, model.$.initialPayment], mortgage, { resetOnDisable: true });
+ * hideWhen(schema.node('mortgage'), () => !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;