@reformer/renderer-json 6.0.0 → 7.0.0-beta.1

package/dist/components/json-form-renderer.d.ts

@@ -32,11 +32,11 @@ export interface JsonFormRendererProps<T> {
  *
  * @typeParam T - Тип формы.
  *
- * @example
+ * @example Форма из JSON-схемы (M1)
  * ```tsx
  * import { useMemo } from 'react';
- * import { createForm } from '@reformer/core';
- * import { Input, FormField } from '@reformer/ui-kit';
+ * import { createModel } from '@reformer/core';
+ * import { Input, Box, FormField } from '@reformer/ui-kit';
  * import {
  *   JsonFormRenderer,
  *   JsonRendererProvider,
@@ -45,12 +45,17 @@ export interface JsonFormRendererProps<T> {
  *   type JsonFormSchema,
  * } from '@reformer/renderer-json';
  *
+ * // Привязки — строки-операторы: '$model(...)', '$component(...)', '$dataSource(...)'.
  * const schema: JsonFormSchema = {
  *   version: '1.0',
  *   root: {
- *     component: 'Box',
+ *     component: '$component(Box)',
  *     children: [
- *       { selector: 'email', model: 'email', component: 'Input' },
+ *       {
+ *         value: '$model(email)',
+ *         component: '$component(Input)',
+ *         componentProps: { label: 'Email' },
+ *       },
  *     ],
  *   },
  * };
@@ -58,31 +63,26 @@ export interface JsonFormRendererProps<T> {
  * type MyForm = { email: string };
  *
  * function MyFormPage() {
- *   // form живёт в page-state и передаётся в registry через closure (см. ниже)
- *   const form = useMemo(() => createForm<MyForm>({
- *     form: { email: { value: '', component: Input, componentProps: { label: 'Email' } } },
- *   }), []);
- *
- *   // registry с FormRoot-closure: компоненты, использующие форму, получают её
- *   // через componentProps closure (JsonFormRenderer НЕ имеет form-prop'а — это by-design,
- *   // т.к. JSON-схема статична, а форма runtime).
+ *   // M1: модель — источник истины значений; листья схемы биндятся к её сигналам.
+ *   const model = useMemo(() => createModel<MyForm>({ email: '' }), []);
  *   const registry = useMemo(() => defineRegistry((reg) => {
- *     reg.field('Input', Input);
- *     reg.container('Box', ({ children }) => <div>{children}</div>);
- *     reg.container(FIELD_WRAPPER, FormField);
+ *     reg.component('Input', Input);
+ *     reg.component('Box', Box);
+ *     reg.component(FIELD_WRAPPER, FormField); // системная обёртка полей
  *   }), []);
  *
+ *   // Модель передаётся через провайдер (settings.model), НЕ пропом рендерера.
  *   return (
- *     <JsonRendererProvider settings={{ registry, form }}>
- *       <JsonFormRenderer schema={schema} />
+ *     <JsonRendererProvider settings={{ registry, model }}>
+ *       <JsonFormRenderer<MyForm> schema={schema} validate={import.meta.env.DEV} />
  *     </JsonRendererProvider>
  *   );
  * }
  * ```
  *
- * **Note**: `JsonFormRenderer` принимает ТОЛЬКО `{ schema, renderBehavior?, onSchemaReady? }`.
+ * **Note**: `JsonFormRenderer` принимает ТОЛЬКО `{ schema, renderBehavior?, onSchemaReady?, validate? }`.
  * Под M1 модель (`FormModel`) передаётся через {@link JsonRendererProvider} settings (`model`);
- * листья JSON-схемы биндятся к её сигналам конвертером `convertJsonToM1Tree`.
+ * листья JSON-схемы биндятся к её сигналам конвертером {@link createRenderSchemaFromJsonM1}.
  *
  * @see [docs/llms/01-overview.md](../../docs/llms/01-overview.md)
  */

package/dist/components/schema-error-panel.d.ts

@@ -4,5 +4,22 @@ export interface SchemaErrorPanelProps {
     /** Человекочитаемые ошибки (`validateFormSchema().errors`). */
     errors: string[];
 }
-/** Список ошибок схемы (path + message), с пометкой источника. Без внешних UI-зависимостей. */
+/**
+ * Список ошибок схемы (path + message), с пометкой источника. Без внешних UI-зависимостей
+ * (инлайн-стили), помечен `role="alert"` и `data-testid="schema-error-panel"`.
+ *
+ * Обычно рендерится автоматически внутри {@link JsonFormRenderer} (при `validate` и невалидной
+ * схеме). Можно использовать напрямую для показа результата `validateFormSchema().errors`.
+ *
+ * @param props - {@link SchemaErrorPanelProps} (массив `errors`).
+ * @returns Панель со списком ошибок.
+ *
+ * @example Показать ошибки валидации схемы вручную
+ * ```tsx
+ * import { validateFormSchema } from '@reformer/renderer-json/validate';
+ *
+ * const { valid, errors } = validateFormSchema(schema, { registry });
+ * if (!valid) return <SchemaErrorPanel errors={errors} />;
+ * ```
+ */
 export declare function SchemaErrorPanel({ errors }: SchemaErrorPanelProps): ReactNode;

package/dist/context/json-renderer-context.d.ts

@@ -30,10 +30,17 @@ export interface JsonRendererProviderProps {
  * Поддерживает вложенность: внутренний провайдер сливается с внешним
  * (внешний имеет приоритет в случае дублей имён в реестре).
  *
- * @example
+ * @example M1: реестр + модель через settings
  * ```tsx
- * <JsonRendererProvider settings={{ registry, fieldWrapper: FormField }}>
- *   <JsonFormRenderer schema={schema} form={form} />
+ * // Модель — источник истины (M1); листья схемы биндятся к её сигналам.
+ * const model = useMemo(() => createModel<MyForm>({ email: '' }), []);
+ * const registry = useMemo(() => defineRegistry((reg) => {
+ *   reg.component('Input', Input);
+ *   reg.component(FIELD_WRAPPER, FormField);
+ * }), []);
+ *
+ * <JsonRendererProvider settings={{ registry, model }}>
+ *   <JsonFormRenderer<MyForm> schema={schema} />
  * </JsonRendererProvider>
  * ```
  */

package/dist/converter/json-to-render-schema.d.ts

@@ -3,13 +3,52 @@ import { FormModel } from '@reformer/core';
 import { JsonFormSchema } from '../types/json-schema';
 import { ComponentRegistry } from '../registry/types';
 /**
- * Сырое дерево RenderNode из JSON (M1) — для `createForm({ model, schema })`.
+ * Сырое дерево RenderNode из JSON (M1) — для `createForm({ model, schema })`. Листья привязываются
+ * к сигналам модели (`'$model(path)'` → `model.signalAt`), компоненты/источники — из реестра.
+ *
+ * @typeParam T - Тип формы (форма данных модели).
+ * @param schema - JSON-схема формы ({@link JsonFormSchema}).
+ * @param registry - Реестр компонентов/источников (см. {@link defineRegistry}).
+ * @param model - Модель данных — источник значений (`FormModel`).
+ * @returns Корневой {@link RenderNode} — кладётся в `createForm({ schema })`.
+ *
+ * @example Собрать форму из JSON-схемы (M1)
+ * ```ts
+ * import { createForm } from '@reformer/core';
+ *
+ * const form = createForm<MyForm>({
+ *   model,
+ *   schema: convertJsonToM1Tree(jsonSchema, registry, model),
+ *   behavior,
+ * });
+ * ```
+ *
  * @group Converter
  */
 export declare function convertJsonToM1Tree<T>(schema: JsonFormSchema, registry: ComponentRegistry, model: FormModel<T>): RenderNode<T>;
 /**
  * `RenderSchemaFn` из JSON (M1) — для `FormRenderer`/`JsonFormRenderer`. Листья привязываются к
  * сигналам модели (`'$model(path)'` → `model.signalAt`), компоненты/источники — из реестра.
+ *
+ * В отличие от {@link convertJsonToM1Tree} (который возвращает готовое дерево), здесь результат —
+ * ленивая функция-фабрика дерева, как её ждёт `createRenderSchema`. Обычно вызывается внутри
+ * {@link JsonFormRenderer}; напрямую нужен для интеграции с `FormRenderer` без JSON-обёртки.
+ *
+ * @typeParam T - Тип формы.
+ * @param schema - JSON-схема формы ({@link JsonFormSchema}).
+ * @param registry - Реестр компонентов/источников (см. {@link defineRegistry}).
+ * @param model - Модель данных — источник значений (`FormModel`).
+ * @returns `RenderSchemaFn<T>` — фабрика {@link RenderNode}-дерева для `createRenderSchema`.
+ *
+ * @example
+ * ```ts
+ * import { createRenderSchema, FormRenderer } from '@reformer/renderer-react';
+ *
+ * const fn = createRenderSchemaFromJsonM1<MyForm>(jsonSchema, registry, model);
+ * const proxy = createRenderSchema<MyForm>(fn);
+ * <FormRenderer render={proxy} />;
+ * ```
+ *
  * @group Converter
  */
 export declare function createRenderSchemaFromJsonM1<T>(schema: JsonFormSchema, registry: ComponentRegistry, model: FormModel<T>): RenderSchemaFn<T>;

package/dist/{index-CI7YxPq2.js → index-BZLcW0SX.js}

@@ -16,13 +16,10 @@ const y = (e) => n(e)?.op === "model", g = (e) => n(e)?.op === "component", S =
   definitions: $
 }, O = r;
 function b(e) {
-  return e.names().filter((t) => {
-    const o = e.get(t)?.type;
-    return o === "field" || o === "container";
-  });
+  return e.names().filter((t) => e.get(t)?.type === "component");
 }
 function N(e) {
-  return e.names().filter((t) => e.get(t)?.type === "source");
+  return e.names().filter((t) => e.get(t)?.type === "dataSource");
 }
 const h = (e) => e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 function j(e) {

package/dist/index.d.ts

@@ -19,4 +19,4 @@ export type { ComponentRegistry, ComponentMetadata, RegistryBuilder } from './re
 export { JsonRendererProvider, useJsonRendererSettings } from './context/json-renderer-context';
 export type { JsonRendererSettings, JsonRendererProviderProps, } from './context/json-renderer-context';
 export { createRenderSchemaFromJsonM1, convertJsonToM1Tree, } from './converter/json-to-render-schema';
-export { formSchemaMetaSchema, buildFormSchemaMetaSchema, getComponentNames, getSourceNames, } from './schema';
+export { formSchemaMetaSchema, buildFormSchemaMetaSchema, getComponentNames, getDataSourceNames, } from './schema';

package/dist/index.js

@@ -1,17 +1,17 @@
 import { jsx as u, jsxs as M } from "react/jsx-runtime";
 import { useContext as N, createContext as O, useMemo as g, useState as C, useEffect as F } from "react";
 import { createRenderSchema as j, FormRenderer as k } from "@reformer/renderer-react";
-import { i as f, a as R, p as m, b as A } from "./index-CI7YxPq2.js";
-import { c as rr, f as er, g as tr, d as nr } from "./index-CI7YxPq2.js";
+import { i as f, a as R, p as m, b as A } from "./index-BZLcW0SX.js";
+import { c as rr, f as er, g as tr, d as nr } from "./index-BZLcW0SX.js";
 class h {
   own = /* @__PURE__ */ new Map();
   parent = null;
   get(e) {
     return this.own.get(e) ?? this.parent?.get(e);
   }
-  getSource(e) {
+  getDataSource(e) {
     const t = this.get(e);
-    if (!(!t || t.type !== "source"))
+    if (!(!t || t.type !== "dataSource"))
       return t.component;
   }
   has(e) {
@@ -34,20 +34,17 @@ class h {
 function K(r) {
   const e = new h();
   return r({
-    field(n, o, i) {
-      e._set(n, { component: o, type: "field", description: i });
+    component(n, o, i) {
+      e._set(n, { component: o, type: "component", description: i });
     },
-    container(n, o, i) {
-      e._set(n, { component: o, type: "container", description: i });
-    },
-    source(n, o, i) {
-      e._set(n, { component: o, type: "source", description: i });
+    dataSource(n, o, i) {
+      e._set(n, { component: o, type: "dataSource", description: i });
     }
   }), e;
 }
-const v = "$fieldWrapper", S = O({});
+const v = "$fieldWrapper", w = O({});
 function Q({ settings: r, children: e }) {
-  const t = N(S), n = g(() => t.registry && r.registry ? h.withParent(t.registry, r.registry) : r.registry ?? t.registry, [t.registry, r.registry]), o = g(() => {
+  const t = N(w), n = g(() => t.registry && r.registry ? h.withParent(t.registry, r.registry) : r.registry ?? t.registry, [t.registry, r.registry]), o = g(() => {
     const i = n?.get(v)?.component;
     return {
       ...t,
@@ -56,10 +53,10 @@ function Q({ settings: r, children: e }) {
       fieldWrapper: r.fieldWrapper ?? i ?? t.fieldWrapper
     };
   }, [t, r, n]);
-  return /* @__PURE__ */ u(S.Provider, { value: o, children: e });
+  return /* @__PURE__ */ u(w.Provider, { value: o, children: e });
 }
-function W() {
-  return N(S);
+function D() {
+  return N(w);
 }
 function $(r) {
   const e = r;
@@ -68,7 +65,7 @@ function $(r) {
 function E(r) {
   return f(r.value);
 }
-function D(r) {
+function W(r) {
   return R(r.component) && !E(r) && !$(r);
 }
 function P(r, e) {
@@ -80,8 +77,8 @@ function P(r, e) {
     throw new Error(
       `Component "${t}" not found in registry. Available: ${e.names().join(", ")}`
     );
-  if (n.type === "source")
-    throw new Error(`Entry "${t}" is a 'source' and cannot be used as $component(...)`);
+  if (n.type === "dataSource")
+    throw new Error(`Entry "${t}" is a 'dataSource' and cannot be used as $component(...)`);
   return n.component;
 }
 function L(r, e) {
@@ -92,22 +89,22 @@ function L(r, e) {
     );
   return t.component;
 }
-function _(r, e) {
+function I(r, e) {
   return e.split(".").reduce((t, n) => t == null ? t : t[n], r);
 }
-function I(r) {
+function V(r) {
   if (r === null || typeof r != "object") return !1;
   const e = r;
   return f(e.value) || f(e.array) || R(e.component);
 }
-function V(r) {
+function _(r) {
   return r == null ? r : JSON.parse(JSON.stringify(r));
 }
 function b(r, e, t) {
   if (A(r)) return L(m(r).arg, t);
   if (R(r)) return P(r, t);
   if (f(r)) return e.signalAt(m(r).arg);
-  if (I(r)) return p(r, e, t);
+  if (V(r)) return p(r, e, t);
   if (Array.isArray(r)) return r.map((n) => b(n, e, t));
   if (r !== null && typeof r == "object") {
     const n = r, o = {};
@@ -116,7 +113,7 @@ function b(r, e, t) {
   }
   return r;
 }
-function w(r, e, t) {
+function S(r, e, t) {
   if (!r) return;
   const n = {};
   for (const o of Object.keys(r)) n[o] = b(r[o], e, t);
@@ -124,13 +121,13 @@ function w(r, e, t) {
 }
 function p(r, e, t) {
   if ($(r)) {
-    const n = _(e, m(r.array).arg), o = r.item.$template, i = r.initialValue;
+    const n = I(e, m(r.array).arg), o = r.item.$template, i = r.initialValue;
     return {
       ...r.selector ? { selector: r.selector } : {},
       array: n,
-      initialValue: () => i ? V(i) : {},
+      initialValue: () => i ? _(i) : {},
       item: (y) => p(o, y, t),
-      componentProps: w(r.componentProps, e, t)
+      componentProps: S(r.componentProps, e, t)
     };
   }
   if (E(r)) {
@@ -139,14 +136,14 @@ function p(r, e, t) {
       ...r.selector ? { selector: r.selector } : {},
       value: o,
       component: P(r.component, t),
-      componentProps: w(r.componentProps, e, t)
+      componentProps: S(r.componentProps, e, t)
     };
   }
-  if (D(r))
+  if (W(r))
     return {
       ...r.selector ? { selector: r.selector } : {},
       component: P(r.component, t),
-      componentProps: w(r.componentProps, e, t),
+      componentProps: S(r.componentProps, e, t),
       children: r.children?.map((n) => p(n, e, t))
     };
   throw new Error(`Invalid JSON node (M1): ${JSON.stringify(r)}`);
@@ -188,7 +185,7 @@ function X({
   onSchemaReady: t,
   validate: n = !1
 }) {
-  const { registry: o, model: i, ...y } = W(), [a, d] = C(
+  const { registry: o, model: i, ...y } = D(), [a, d] = C(
     n ? void 0 : null
   );
   F(() => {
@@ -231,13 +228,13 @@ export {
   K as defineRegistry,
   er as formSchemaMetaSchema,
   tr as getComponentNames,
-  nr as getSourceNames,
+  nr as getDataSourceNames,
   $ as isArrayNode,
   R as isComponentOp,
-  D as isContainerNode,
+  W as isContainerNode,
   A as isDataSourceOp,
   E as isFieldNode,
   f as isModelOp,
   m as parseOperator,
-  W as useJsonRendererSettings
+  D as useJsonRendererSettings
 };

package/dist/operators.d.ts

@@ -4,8 +4,8 @@
  * JSON нельзя «вызвать функцию», поэтому привязки кодируются СТРОКАМИ функц-стиля с дискриминатором:
  *
  * - `"$model(path)"`        — путь к полю/массиву модели: лист → `model.signalAt(path)`, массив → `model.<path>`.
- * - `"$component(Name)"`    — имя компонента в реестре (`reg.field`/`reg.container`).
- * - `"$dataSource(NAME)"`   — имя registry-source (`reg.source`): options/itemLabel/константы/loading-компоненты.
+ * - `"$component(Name)"`    — имя компонента в реестре (`reg.component`).
+ * - `"$dataSource(NAME)"`   — имя registry-source (`reg.dataSource`): options/itemLabel/константы/loading-компоненты.
  *
  * Схема остаётся чистым JSON (копируется в `.json`, приходит строкой с сервера). Типобезопасность
  * на этапе компиляции даётся template-literal типами ({@link ModelOp} и т.д.) — литерал
@@ -30,6 +30,9 @@ export interface ParsedOperator {
  * Разбор строки-оператора `"$op(arg)"`. Возвращает `null` для не-операторов (обычных строк),
  * чтобы вызывающий оставил значение как есть.
  *
+ * @param value - Проверяемое значение (не-строки сразу дают `null`).
+ * @returns {@link ParsedOperator} (`{ op, arg }`) либо `null`, если строка — не оператор.
+ *
  * @example
  * ```ts
  * parseOperator('$model(loanType)');   // { op: 'model', arg: 'loanType' }
@@ -38,9 +41,45 @@ export interface ParsedOperator {
  * ```
  */
 export declare function parseOperator(value: unknown): ParsedOperator | null;
-/** Type-guard: строка — `"$model(...)"`. */
+/**
+ * Type-guard: строка — оператор `"$model(...)"` (привязка к полю/массиву модели).
+ *
+ * @param v - Проверяемое значение.
+ * @returns `true`, если `v` — {@link ModelOp}.
+ *
+ * @example Сузить тип значения prop до ModelOp
+ * ```ts
+ * if (isModelOp(value)) {
+ *   const path = parseOperator(value)!.arg; // 'loanType'
+ * }
+ * ```
+ */
 export declare const isModelOp: (v: unknown) => v is ModelOp;
-/** Type-guard: строка — `"$component(...)"`. */
+/**
+ * Type-guard: строка — оператор `"$component(...)"` (ссылка на компонент реестра).
+ *
+ * @param v - Проверяемое значение.
+ * @returns `true`, если `v` — {@link ComponentOp}.
+ *
+ * @example
+ * ```ts
+ * if (isComponentOp(node.component)) {
+ *   const name = parseOperator(node.component)!.arg; // 'Select'
+ * }
+ * ```
+ */
 export declare const isComponentOp: (v: unknown) => v is ComponentOp;
-/** Type-guard: строка — `"$dataSource(...)"`. */
+/**
+ * Type-guard: строка — оператор `"$dataSource(...)"` (ссылка на registry-source).
+ *
+ * @param v - Проверяемое значение.
+ * @returns `true`, если `v` — {@link DataSourceOp}.
+ *
+ * @example
+ * ```ts
+ * if (isDataSourceOp(props.options)) {
+ *   const name = parseOperator(props.options)!.arg; // 'LOAN_TYPES'
+ * }
+ * ```
+ */
 export declare const isDataSourceOp: (v: unknown) => v is DataSourceOp;

package/dist/registry/component-registry.d.ts

@@ -3,7 +3,7 @@ export declare class ComponentRegistryImpl implements ComponentRegistry {
     private own;
     private parent;
     get(name: string): ComponentMetadata | undefined;
-    getSource<T = unknown>(name: string): T | undefined;
+    getDataSource<T = unknown>(name: string): T | undefined;
     has(name: string): boolean;
     names(): string[];
     _set(name: string, metadata: ComponentMetadata): void;
@@ -15,7 +15,7 @@ export declare class ComponentRegistryImpl implements ComponentRegistry {
  * Реестр обязателен для работы {@link JsonFormRenderer} — иначе компоненты,
  * упомянутые в JSON-схеме, не отрезолвятся.
  *
- * @param fn - Builder-callback. Получает {@link RegistryBuilder} с методами `field`, `container`, `source`.
+ * @param fn - Builder-callback. Получает {@link RegistryBuilder} с методами `component`, `dataSource`.
  * @returns Готовый {@link ComponentRegistry}, который кладётся в `JsonRendererProvider`.
  *
  * @example
@@ -24,10 +24,10 @@ export declare class ComponentRegistryImpl implements ComponentRegistry {
  * import { Input, Select, FormField } from '@reformer/ui-kit';
  *
  * const registry = defineRegistry((reg) => {
- *   reg.field('Input', Input);
- *   reg.field('Select', Select);
- *   reg.container(FIELD_WRAPPER, FormField);
- *   reg.source('LOAN_TYPES', [
+ *   reg.component('Input', Input);
+ *   reg.component('Select', Select);
+ *   reg.component(FIELD_WRAPPER, FormField);
+ *   reg.dataSource('LOAN_TYPES', [
  *     { value: 'consumer', label: 'Потребительский' },
  *     { value: 'mortgage', label: 'Ипотека' },
  *   ]);

package/dist/registry/constants.d.ts

@@ -10,7 +10,7 @@
  * import { FormField } from '@reformer/ui-kit';
  *
  * const registry = defineRegistry((reg) => {
- *   reg.container(FIELD_WRAPPER, FormField);
+ *   reg.component(FIELD_WRAPPER, FormField);
  * });
  * ```
  */

package/dist/registry/types.d.ts

@@ -1,18 +1,18 @@
 import { ComponentType } from 'react';
 /**
- * Запись реестра. Хранит сам компонент (или source-значение) и его роль.
+ * Запись реестра. Хранит сам компонент (или dataSource-значение) и его роль.
  *
  * @typeParam P - Пропсы компонента (для `field`/`container`).
  *
  * @example
  * ```typescript
  * const meta: ComponentMetadata = registry.get('Input')!;
- * meta.type; // 'field'
+ * meta.type; // 'component'
  * ```
  */
 export interface ComponentMetadata<P = any> {
     component: ComponentType<P> | unknown;
-    type: 'field' | 'container' | 'source';
+    type: 'component' | 'dataSource';
     description?: string;
 }
 /**
@@ -31,7 +31,7 @@ export interface ComponentMetadata<P = any> {
  */
 export interface ComponentRegistry {
     get(name: string): ComponentMetadata | undefined;
-    getSource<T = unknown>(name: string): T | undefined;
+    getDataSource<T = unknown>(name: string): T | undefined;
     has(name: string): boolean;
     names(): string[];
 }
@@ -41,14 +41,20 @@ export interface ComponentRegistry {
  * @example
  * ```typescript
  * defineRegistry((reg: RegistryBuilder) => {
- *   reg.field('Input', Input);
- *   reg.container('Box', Box);
- *   reg.source('LOAN_TYPES', LOAN_TYPES);
+ *   reg.component('Input', Input);
+ *   reg.component('Box', Box);
+ *   reg.dataSource('LOAN_TYPES', LOAN_TYPES);
  * });
  * ```
  */
 export interface RegistryBuilder {
-    field<P>(name: string, component: ComponentType<P>, description?: string): void;
-    container<P>(name: string, component: ComponentType<P>, description?: string): void;
-    source<T>(name: string, value: T, description?: string): void;
+    /**
+     * Зарегистрировать React-компонент под именем — доступен в схеме как
+     * `$component(name)`. Одним методом регистрируются и компоненты-листья
+     * (Input/Select), и контейнеры (Box/Section/FormField): роль узла (лист vs
+     * контейнер) определяется структурой узла схемы (`value` vs `children`),
+     * а не регистрацией.
+     */
+    component<P>(name: string, component: ComponentType<P>, description?: string): void;
+    dataSource<T>(name: string, value: T, description?: string): void;
 }

package/dist/schema/index.d.ts

@@ -1,10 +1,42 @@
 import { ComponentRegistry } from '../registry/types';
-/** Базовая мета-схема form-DSL (draft-07): структура + синтаксис операторов, имена не ограничены. */
+/**
+ * Базовая мета-схема form-DSL (draft-07): структура узлов + синтаксис операторов, имена компонентов
+ * НЕ ограничены (паттерн `$component(...)` открыт). Для сужения до конкретного реестра —
+ * {@link buildFormSchemaMetaSchema}. Используется как `$schema` в IDE и как база валидатора.
+ *
+ * @example Подключить как `$schema` в JSON-файле схемы
+ * ```ts
+ * // record можно записать в файл и сослаться на него из "$schema" JSON-схемы.
+ * formSchemaMetaSchema.$schema; // 'http://json-schema.org/draft-07/schema#'
+ * ```
+ */
 export declare const formSchemaMetaSchema: Record<string, unknown>;
-/** Имена компонентов реестра (`reg.field`/`reg.container`). */
+/**
+ * Имена компонентов реестра (тип `component`) — то, что валидно в `$component(...)`.
+ *
+ * @param registry - Реестр (см. {@link defineRegistry}).
+ * @returns Массив имён компонентов.
+ *
+ * @example Сузить мета-схему до компонентов реестра
+ * ```ts
+ * const names = getComponentNames(registry); // ['Input', 'Select', 'Box', ...]
+ * const schema = buildFormSchemaMetaSchema({ componentNames: names });
+ * ```
+ */
 export declare function getComponentNames(registry: ComponentRegistry): string[];
-/** Имена registry-source (`reg.source`): options/itemLabel/константы/loading-компоненты. */
-export declare function getSourceNames(registry: ComponentRegistry): string[];
+/**
+ * Имена registry-dataSource (`reg.dataSource`) — то, что валидно в `$dataSource(...)`:
+ * options/itemLabel/константы/loading-компоненты.
+ *
+ * @param registry - Реестр (см. {@link defineRegistry}).
+ * @returns Массив имён источников.
+ *
+ * @example
+ * ```ts
+ * getDataSourceNames(registry); // ['LOAN_TYPES', 'GENDERS', 'LoadingState', ...]
+ * ```
+ */
+export declare function getDataSourceNames(registry: ComponentRegistry): string[];
 /**
  * Конкретная мета-схема: базовая + (если заданы `componentNames`) сужение паттерна `$component(...)`
  * до enum имён (`^\$component\((Input|Select|…)\)$`). `$dataSource`-имена JSON Schema'й не покрыть

package/dist/types/json-schema.d.ts

@@ -68,9 +68,49 @@ export interface JsonFormSchema {
     /** Корневой узел. */
     root: JsonNode;
 }
-/** Type-guard: узел — массив (`array: '$model(...)'` + `item.$template`). Проверять ПЕРВЫМ. */
+/**
+ * Type-guard: узел — массив (`array: '$model(...)'` + `item.$template`). Проверять ПЕРВЫМ
+ * (лист/контейнер отсеиваются после, т.к. массив тоже несёт `$model`).
+ *
+ * @param node - Узел JSON-схемы.
+ * @returns `true`, если узел — {@link JsonArrayNode}.
+ *
+ * @example Сузить тип узла перед доступом к `item.$template`
+ * ```ts
+ * if (isArrayNode(node)) {
+ *   node.array;            // ModelOp
+ *   node.item.$template;   // JsonNode
+ * }
+ * ```
+ */
 export declare function isArrayNode(node: JsonNode): node is JsonArrayNode;
-/** Type-guard: узел — лист (`value: '$model(...)'`). */
+/**
+ * Type-guard: узел — лист (`value: '$model(...)'`).
+ *
+ * @param node - Узел JSON-схемы.
+ * @returns `true`, если узел — {@link JsonFieldNode}.
+ *
+ * @example Сузить тип узла перед доступом к `value`/`component`
+ * ```ts
+ * if (isFieldNode(node)) {
+ *   node.value;      // ModelOp
+ *   node.component;  // ComponentOp | undefined
+ * }
+ * ```
+ */
 export declare function isFieldNode(node: JsonNode): node is JsonFieldNode;
-/** Type-guard: узел — контейнер (`component: '$component(...)'`, без `value`/`array`). */
+/**
+ * Type-guard: узел — контейнер (`component: '$component(...)'`, без `value`/`array`).
+ *
+ * @param node - Узел JSON-схемы.
+ * @returns `true`, если узел — {@link JsonContainerNode}.
+ *
+ * @example Сузить тип узла перед обходом `children`
+ * ```ts
+ * if (isContainerNode(node)) {
+ *   node.component;   // ComponentOp
+ *   node.children?.forEach(walk);
+ * }
+ * ```
+ */
 export declare function isContainerNode(node: JsonNode): node is JsonContainerNode;

package/dist/validate.d.ts

@@ -9,10 +9,16 @@ export interface FormSchemaValidationResult {
 export interface ValidateFormSchemaOptions {
     registry?: ComponentRegistry;
     componentNames?: string[];
-    sourceNames?: string[];
+    dataSourceNames?: string[];
 }
 /**
- * Валидирует form-DSL JSON-схему. Если передан `registry`, имена компонентов/source берутся из него.
+ * Валидирует form-DSL JSON-схему. Если передан `registry`, имена компонентов/source берутся из него
+ * (иначе можно задать `componentNames`/`dataSourceNames` явно). Тянет `ajv` — живёт в subpath
+ * `@reformer/renderer-json/validate`, чтобы не попадать в основной render-бандл.
+ *
+ * @param schema - Проверяемая JSON-схема (обычно {@link JsonFormSchema}, но принимает `unknown`).
+ * @param opts - {@link ValidateFormSchemaOptions}: `registry` либо явные списки имён.
+ * @returns {@link FormSchemaValidationResult} — `{ valid, errors }` (ошибки — путь + сообщение).
  *
  * @example
  * ```ts

package/dist/validate.js

@@ -1,4 +1,4 @@
-import { g as an, d as on, f as un, p as cn } from "./index-CI7YxPq2.js";
+import { g as an, d as on, f as un, p as cn } from "./index-BZLcW0SX.js";
 function ln(e) {
   return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
 }
@@ -4456,7 +4456,7 @@ function qt(e, r, S, d, g) {
       qt(f, r ? `${r}.${s}` : s, S, d, g);
 }
 function gs(e, r = {}) {
-  const S = r.componentNames ?? (r.registry ? an(r.registry) : void 0), d = r.sourceNames ?? (r.registry ? on(r.registry) : void 0), g = [], f = new vs({ allErrors: !0 }).compile(un);
+  const S = r.componentNames ?? (r.registry ? an(r.registry) : void 0), d = r.dataSourceNames ?? (r.registry ? on(r.registry) : void 0), g = [], f = new vs({ allErrors: !0 }).compile(un);
   if (!f(e))
     for (const c of f.errors ?? [])
       g.push(`${c.instancePath || "/"} ${c.message ?? "invalid"}`.trim());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reformer/renderer-json",
-  "version": "6.0.0",
+  "version": "7.0.0-beta.1",
   "description": "JSON-based form renderer for @reformer ecosystem",
   "type": "module",
   "main": "./dist/index.js",