@fragmentsx/runtime-react 0.2.0-dev-20260902143145 → 0.2.0-dev-20260910122311

package/dist/index.d.ts

@@ -1,13 +1,12 @@
 import { ComponentType } from 'react';
 import { Context } from 'react';
-import { createFragmentsClient } from '../../fragments-client/src/index.ts';
-import { CreateFragmentsClientOptions } from '../../fragments-client/src/index.ts';
+import { createFragmentsClient } from '@fragmentsx/fragments-client';
+import { CreateFragmentsClientOptions } from '@fragmentsx/fragments-client';
 import { FC } from 'react';
-import { FragmentsApiVersionError } from '../../fragments-client/src/index.ts';
-import { FragmentsAreaError } from '../../fragments-client/src/index.ts';
-import { FragmentsLoadError } from '../../fragments-client/src/index.ts';
+import { FragmentsApiVersionError } from '@fragmentsx/fragments-client';
+import { FragmentsAreaError } from '@fragmentsx/fragments-client';
+import { FragmentsLoadError } from '@fragmentsx/fragments-client';
 import { GraphState } from '@graph-state/core';
-import { JSX } from 'react/jsx-runtime';
 import { ReactElement } from 'react';
 import { ReactNode } from 'react';
 
@@ -60,12 +59,136 @@ export declare interface AreaProps {
     };
 }
 
+/**
+ * Тип поля `Array`. Вырожденный вердикт — `never[]`, когда `definition`
+ * отсутствует: элементы читать нельзя, и это ошибка компиляции, а не
+ * `unknown[]`/`any[]`, которые открыли бы всё.
+ */
+declare type ArrayFieldType<F extends SchemaFieldDescriptor, D extends number> = F extends {
+    definition: infer Def;
+} ? Def extends SchemaFieldDescriptor ? D extends 0 ? ValueOfVariableType<"Array"> : FieldValueType<Def, PrevDepth<D>>[] : never[] : never[];
+
+/** Тип-цель `satisfies` для литерала `schema` артефакта (SURF-06). */
+export declare type ArtifactSchema = Readonly<Record<string, ArtifactSchemaField>>;
+
+/** Дескриптор одного поля литерала `schema` на верхнем уровне вложенности (корень — `MAX_SCHEMA_DEPTH`). */
+export declare type ArtifactSchemaField = ArtifactSchemaFieldAtDepth<typeof MAX_SCHEMA_DEPTH>;
+
+declare type ArtifactSchemaFieldAtDepth<D extends number> = D extends 0 ? never : (ArtifactSchemaFieldCommon & {
+    readonly type: "String";
+    readonly defaultValue?: string;
+    readonly placeholder?: string;
+    readonly isTextarea?: boolean;
+    readonly isRich?: boolean;
+}) | (ArtifactSchemaFieldCommon & {
+    readonly type: "Number";
+    readonly defaultValue?: number;
+    readonly min?: number;
+    readonly max?: number;
+    readonly step?: number;
+    readonly displayStepper?: boolean;
+}) | (ArtifactSchemaFieldCommon & {
+    readonly type: "Boolean";
+    readonly defaultValue?: boolean;
+}) | (ArtifactSchemaFieldCommon & {
+    readonly type: "Color";
+    readonly defaultValue?: string;
+}) | (ArtifactSchemaFieldCommon & {
+    readonly type: "Image";
+    readonly defaultValue?: string | null;
+}) | (ArtifactSchemaFieldCommon & {
+    readonly type: "Link";
+    readonly defaultValue?: string;
+}) | (ArtifactSchemaFieldCommon & {
+    readonly type: "Enum";
+    readonly defaultValue?: string;
+    readonly cases?: ReadonlyArray<{
+        readonly id: string;
+        readonly name: string;
+    }>;
+}) | (ArtifactSchemaFieldCommon & {
+    readonly type: "Object";
+    readonly defaultValue?: Record<string, unknown>;
+    readonly fields?: Record<string, ArtifactSchemaFieldAtDepth<PrevDepth<D>>>;
+}) | (ArtifactSchemaFieldCommon & {
+    readonly type: "Array";
+    readonly defaultValue?: readonly unknown[];
+    readonly definition?: ArtifactSchemaFieldAtDepth<PrevDepth<D>>;
+});
+
+/**
+ * Тип-цель литерала `schema` артефакта (Phase 100, план 100-01, SURF-06).
+ *
+ * Второе представление канона, а не переиспользование valibot-схем
+ * (`packages/fragment-compiler/src/gate/schemaLiteralSchemas.ts`) напрямую:
+ * прогон планирования показал, что `v.InferInput` не выдерживает рекурсию —
+ * `makeVariableLiteralSchema` объявлен с возвращаемым типом
+ * `v.BaseSchema<any, any, any>`, и `v.lazy(() => makeVariableLiteralSchema(...))`
+ * стирает форму вложенного уровня до `any` (см. `research/questions.md`,
+ * ветвь (б)). Переезд valibot-схем в `definition` цели не достигает — второе
+ * представление неизбежно, и оно обязано стоять там, откуда его видит
+ * артефакт (`@fragmentsx/runtime-react` реэкспортирует ТОЛЬКО типы, без
+ * зависимости от `fragment-compiler`).
+ *
+ * Девять вариантов буквально повторяют девять литеральных valibot-схем
+ * `schemaLiteralSchemas.ts` — согласие набора полей в обе стороны держит
+ * инвариант-тест `artifactSchemaInvariant.test.ts` (задача 3), а не
+ * компилятор: `InferInput` для этого не годится (см. выше).
+ *
+ * Зарезервированные типы словаря (`Event`, `Goal`, `ComponentInstance`,
+ * `Date`, `'fragment'`) в объединение НЕ входят — этим `ArtifactSchema`
+ * отличается от `SchemaFieldDescriptor` (`propsFromSchema.ts`), у которого
+ * `type: VariableType` принимает любой тип словаря. Ключи `RESERVED_SCHEMA_KEYS`
+ * (`__proto__`/`constructor`/`prototype`/`_id`/`_type`/`parent`/`$ref`) типом
+ * не выражаются и остаются структурным кодом `SCHEMA_RESERVED_KEY` в гейте —
+ * TypeScript не умеет запретить конкретные строковые ключи объекта общим
+ * механизмом без потери индексной сигнатуры.
+ *
+ * Предел вложенности приходит СНАРУЖИ через `typeof MAX_SCHEMA_DEPTH`, а
+ * отсчёт — та же таблица `PrevDepth`, что уже стоит в `propsFromSchema.ts`:
+ * второй копии литерала предела в этом файле нет. За пределом глубины
+ * вложенный дескриптор — `never`, а не `any` (T-100-01): схема четвёртого
+ * уровня обязана быть ошибкой компиляции, симметрично `v.never()` в
+ * `makeVariableLiteralSchema`.
+ */
+declare interface ArtifactSchemaFieldCommon {
+    readonly required?: boolean;
+    readonly editable?: boolean;
+}
+
 /**
  * Browser-specific options — identical к CreateFragmentsClientOptions, но без `inject`.
  * `inject` pre-populated через `injectStylesheet` из runtime-react автоматически.
  */
 declare type BrowserClientOptions = Omit<CreateFragmentsClientOptions, "inject">;
 
+/** Раскрывает кортеж/массив `cases` до union строковых литералов `id`. */
+declare type CaseIds<Cases> = Cases extends ReadonlyArray<infer Case> ? Case extends {
+    readonly id: infer Id;
+} ? Id extends string ? Id : never : never : never;
+
+/**
+ * Представление ПОТРЕБИТЕЛЯ (Phase 97, план 97-02, TYPES-04) — то, что видит
+ * вызывающий, конструирующий `props` для артефакта СНАРУЖИ (например, тест
+ * или превью). Отличается от `PropsFromSchema` РОВНО одним: значение по
+ * умолчанию на верхнем уровне обязательности НЕ создаёт (`ConsiderDefault =
+ * false`) — подставит его рантайм (`resolveVariantProps`), а не вызывающий.
+ *
+ * Внутри `Object.fields` правило ОДНО на оба представления — только
+ * `required: true` (D-97-05): в домене схемы артефакта вложенные дефолты не
+ * применяет никто (`resolveVariantProps` не рекурсирует в `descriptor.fields`
+ * — это свойство ИМЕННО этого домена, не общий факт кодовой базы: в домене
+ * уровневых переменных проекта, который читает `ProjectPropertyDescriptor` в
+ * `@fragmentsx/fragment-compiler`, рекурсивное применение дефолтов ЕСТЬ и
+ * работает в проде тремя копиями, см. `composeScopePropertyValue.ts`).
+ *
+ * ГРАНИЦА ПРИМЕНИМОСТИ (WR-03, Phase 97 review) — та же, что у
+ * `PropsFromSchema` (см. её докстринг): `S` обязан выводиться из ЛИТЕРАЛА,
+ * широкая аннотация переменной схемы до `typeof` схлопывает generic молча,
+ * без ошибки компиляции.
+ */
+export declare type ConsumerPropsFromSchema<S extends Record<string, SchemaFieldDescriptor>> = PropsShape<S, false, typeof MAX_SCHEMA_DEPTH>;
+
 /**
  * Создаёт FragmentsClient с pre-populated inject = injectStylesheet (BLOCKER-4-wiring bridge).
  *
@@ -77,8 +200,71 @@ export declare function createBrowserClient(opts: BrowserClientOptions): ReturnT
 /**
  * Дефолтное значение, когда Provider не установлен (потребитель вне
  * `FragmentRenderer`, например изолированный юнит-тест компонента).
+ *
+ * Литерал типизирован утверждением типа (Phase 97): пока `ProjectProperties`
+ * пуст, пустой объектный литерал ему соответствует и без утверждения; после
+ * расширения потребителем (`declare module` в его собственном файле) этот
+ * платформенный код по-прежнему обязан компилироваться БЕЗ расширения рядом
+ * — утверждение фиксирует эту границу, а не обходит проверку.
+ */
+export declare const defaultProjectProperties: ProjectProperties;
+
+/**
+ * Отсчёт глубины на уровне типов — конечная таблица декремента, а не
+ * повторный литерал предела: сам предел приходит СНАРУЖИ через `typeof
+ * MAX_SCHEMA_DEPTH` (канон `@fragmentsx/definition/constants`), таблица лишь
+ * реализует арифметику «минус один» для чисел вплоть до предела с запасом.
+ *
+ * Экспортирован (Phase 100, план 100-01) — `artifactSchema.ts` использует ТУ ЖЕ
+ * машинерию отсчёта, а не второй скопированный литерал предела: копия таблицы
+ * несла бы буквенный `3` вторым местом, которое проверка `grep` плана обязана
+ * не найти нигде, кроме строки с `MAX_SCHEMA_DEPTH`.
  */
-export declare const defaultProjectProperties: Record<string, unknown>;
+declare type DepthCountdown = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+/**
+ * Тип поля `Enum`. Вырожденный вердикт (Phase 97, T-97-02-03) — `never`,
+ * когда `cases` отсутствует ИЛИ пуст: у перечисления без вариантов нет ни
+ * одного допустимого значения, `never` делает чтение такого поля ошибкой
+ * компиляции вместо тихого `string` (базовое отображение таблицы).
+ *
+ * Проверка присутствия ключа идёт через `F extends { cases: infer Cases }`
+ * (сравнение по факту наличия свойства в конкретной инстанциации F), а НЕ
+ * через прямой индексированный доступ `F["cases"]` — последний в generic-
+ * контексте резолвится по ограничению (`SchemaFieldDescriptor`), а не по
+ * фактической форме F, и не отличил бы «cases нет» от «cases есть».
+ */
+declare type EnumFieldType<F extends SchemaFieldDescriptor> = F extends {
+    cases: infer Cases;
+} ? Cases extends ReadonlyArray<{
+    readonly id: string;
+}> ? Cases extends readonly [] ? never : CaseIds<Cases> : never : never;
+
+/**
+ * Правило обязательности ВЕРХНЕГО уровня, параметризованное одним флагом
+ * `ConsiderDefault` — единственное различие между `PropsFromSchema`
+ * (`ConsiderDefault = true`, домен компонента) и `ConsumerPropsFromSchema`
+ * (`ConsiderDefault = false`, домен потребителя, подставляющего значение по
+ * умолчанию сам). Внутри `Object.fields` этот же обход вызывается с
+ * `ConsiderDefault = false` НЕЗАВИСИМО от верхнего представления — правило
+ * вложенного уровня одно на оба представления (D-97-05).
+ *
+ * `required: true` И `defaultValue` одновременно — поле обязательно
+ * (признаки не отменяют друг друга: `HasRequiredTrue` проверяется первым и
+ * коротким замыканием даёт `true`, не заглядывая в `ConsiderDefault`).
+ */
+declare type FieldRequired<F extends SchemaFieldDescriptor, ConsiderDefault extends boolean> = HasRequiredTrue<F> extends true ? true : ConsiderDefault extends true ? HasDefaultValueKey<F> : false;
+
+/**
+ * Тип ЗНАЧЕНИЯ одного поля на глубине обхода `D` — три сужения (Enum/Object/
+ * Array), остальные десять типов — прямая проекция таблицы
+ * `VARIABLE_TYPE_TO_TS`. `F["type"]` внутри условного типа резолвится ПО
+ * КОНКРЕТНОЙ инстанциации F (условный тип с голым параметром типа
+ * пере-вычисляется на каждой инстанциации) — в отличие от прямого
+ * индексированного доступа вне условного типа, который резолвился бы по
+ * ограничению.
+ */
+declare type FieldValueType<F extends SchemaFieldDescriptor, D extends number> = F["type"] extends "Enum" ? EnumFieldType<F> : F["type"] extends "Object" ? ObjectFieldType<F, D> : F["type"] extends "Array" ? ArrayFieldType<F, D> : ValueOfVariableType<F["type"]>;
 
 export declare interface FragmentMetrics {
     reachGoal: (info: ReachGoalInfo) => void;
@@ -132,11 +318,15 @@ export declare const FragmentsClientContext: Context<FragmentsClient | null>;
 /**
  * React-компонент-обёртка для установки FragmentsClient в Context. Эмиссия
  * compiled-output её не вызывает — это app-level wiring entry point.
+ *
+ * Явная аннотация возврата (WR-01, Phase 97 review) — требуется страховкой
+ * барреля `sdk-surface.test.ts` («каждая поверхность несёт явную аннотацию
+ * возврата»), см. докстринг `getExplicitReturnTypeNode` там же.
  */
 export declare function FragmentsClientProvider(props: {
     value: FragmentsClient;
     children: ReactNode;
-}): JSX.Element;
+}): ReactElement;
 
 export { FragmentsLoadError }
 
@@ -157,13 +347,21 @@ declare interface FragmentsProviderProps {
     children: ReactNode;
 }
 
-export declare function FragmentStylesheet({ href, fragmentKey }: FragmentStylesheetProps): JSX.Element | null;
+export declare function FragmentStylesheet({ href, fragmentKey, }: FragmentStylesheetProps): ReactElement | null;
 
 declare interface FragmentStylesheetProps {
     href: string;
     fragmentKey: string;
 }
 
+/** Присутствие КЛЮЧА `defaultValue`, а не истинность его значения (Phase 97, план 97-02): `defaultValue: 0`/`''`/`false`/`null` — присутствующие значения, `keyof F` включает ключ ровно тогда, когда он был указан в литерале поля. */
+declare type HasDefaultValueKey<F> = "defaultValue" extends keyof F ? true : false;
+
+/** Есть ли у поля флаг `required: true` — ЕДИНСТВЕННОЕ правило обязательности внутри `Object.fields` на любом уровне (D-97-05). */
+declare type HasRequiredTrue<F> = F extends {
+    required: true;
+} ? true : false;
+
 /**
  * Инжектирует `<link rel="stylesheet">` в `document.head` с ref-count dedup.
  *
@@ -176,6 +374,13 @@ export declare const injectStylesheet: (href: string, key: string) => Stylesheet
 
 export declare const InstanceIdContext: Context<string | null>;
 
+/**
+ * Единственный литерал предела глубины вложенности Object/Array-переменных
+ * (D-71-12) — тем же значением пользуется гейт публикации (`fragment-compiler`
+ * ре-экспортирует эту константу вместо собственного литерала).
+ */
+declare const MAX_SCHEMA_DEPTH = 3;
+
 /**
  * React Context для инъекции cache-reader'а в дерево компонентов.
  * Null default = «provider не установлен» (no-provider signal).
@@ -185,6 +390,19 @@ export declare const ModulesMapContext: Context<ModulesMapContextValue | null>;
 /**
  * Значение ModulesMapContext. Единственная fn — cache-reader (D-05).
  *
+ * `read` возвращает `ComponentType` с широким параметром типа — ЗАПИСАННОЕ
+ * РЕШЕНИЕ (D-97-12), не недоделка. Тип чужого динамически загружаемого
+ * компонента статически неизвестен по построению: фрагмент грузится по
+ * числовому идентификатору в момент выполнения, и его форма не известна ни
+ * одному участнику сборки. Оба мыслимых сужения хуже неопределённости:
+ * параметр типа от вызывающего — то же утверждение типа, только отмытое и
+ * перенесённое на вызывающего, запрещено Г-03; сужение до пустого
+ * объектного параметра типа честно и бесполезно — артефакт всё равно не
+ * может употребить чужой компонент иначе, чем передав его в JSX. ЗАПРЕЩЕНО
+ * «чинить» эту сигнатуру утверждением типа или параметром типа от
+ * вызывающего — `sdk-surface.test.ts` требует этого маркера у сигнатуры и
+ * красит тест при его снятии.
+ *
  * @param id - числовой идентификатор фрагмента
  * @returns ComponentType (cache hit) | throws Promise (pending) | throws FragmentsLoadError (missing)
  */
@@ -212,7 +430,83 @@ declare interface ModulesMapProviderProps {
     children: ReactNode;
 }
 
-export declare const ProjectPropertiesContext: Context<Record<string, unknown> | null>;
+/**
+ * Тип поля `Object`. Вырожденный вердикт — литеральный `{}` (пустой
+ * объектный тип БЕЗ индексной сигнатуры), когда `fields` отсутствует или
+ * пуст: `{}` даёт ошибку компиляции (TS2339) на обращении к произвольному
+ * ключу, а базовое отображение таблицы `Record<string, unknown>` этого не
+ * делает — оно как раз ДАЁТ доступ к любому ключу молча, и это ровно то,
+ * чего вырожденный дескриптор не должен разрешать.
+ *
+ * За пределом `MAX_SCHEMA_DEPTH` (D-глубина исчерпана) обход не идёт дальше:
+ * возвращается базовое отображение таблицы, а не `any`.
+ */
+declare type ObjectFieldType<F extends SchemaFieldDescriptor, D extends number> = F extends {
+    fields: infer Fields;
+} ? Fields extends Record<string, SchemaFieldDescriptor> ? keyof Fields extends never ? {} : D extends 0 ? ValueOfVariableType<"Object"> : PropsShape<Fields, false, PrevDepth<D>> : {} : {};
+
+declare type PrevDepth<D extends number> = D extends 0 ? never : DepthCountdown[D];
+
+/**
+ * Расширяемый интерфейс SDK (Phase 97, D-97-01) — единственная поверхность,
+ * которую расширяет сгенерированный `project.d.ts`. Объявлен пустым здесь
+ * же, а не в отдельном модуле типов: контекст и его дефолт ниже типизируются
+ * ИМ ЖЕ, и разводить объявление с его единственными потребителями незачем.
+ */
+export declare interface ProjectProperties {
+}
+
+export declare const ProjectPropertiesContext: Context<ProjectProperties | null>;
+
+/**
+ * Внутрикомпонентное представление типа `props` (Phase 97, план 97-02,
+ * TYPES-03) — то, что артефакт видит у СЕБЯ внутри компонента. Поле верхнего
+ * уровня обязательно при `required: true` ИЛИ при присутствии ключа
+ * `defaultValue` (`ConsiderDefault = true`): `resolveVariantProps`
+ * (`helpers/resolveVariantProps.ts:35,62`) идёт только по верхнеуровневым
+ * ключам и подставляет `defaultValue` буквально — внутри компонента такое
+ * поле гарантировано присутствует.
+ *
+ * `defaultValue: null` — присутствующее значение, поле обязательно так же,
+ * как и с любым другим значением (0/''/false); граница «присутствует» и
+ * «осмысленно» здесь расходится СОЗНАТЕЛЬНО: `resolveVariantProps` подставит
+ * буквально `null`, и внутри компонента поле будет — `null`, не отсутствовать.
+ *
+ * Схема без полей (`{}`) даёт тип без пригодных ключей — обращение к
+ * произвольному ключу такого `props` есть ошибка компиляции.
+ *
+ * ГРАНИЦА ПРИМЕНИМОСТИ (WR-03, Phase 97 review): `S` ОБЯЗАН выводиться из
+ * ЛИТЕРАЛА (`typeof schema` на буквальном объектном литерале, как в каждом
+ * примере `artifactExamples.ts`). Если потребитель аннотирует переменную
+ * схемы широким типом ДО `typeof` —
+ * `const schema: Record<string, SchemaFieldDescriptor> = {...}` — `S`
+ * инстанциируется как этот широкий тип, `keyof S` схлопывается до `string`,
+ * и КАЖДОЕ поле резолвится до целого `SchemaFieldDescriptor` вместо своего
+ * буквального поля: `HasDefaultValueKey`/`HasRequiredTrue`/`FieldValueType`
+ * дают бесполезный широкий результат ОДИНАКОВО для всех полей — БЕЗ единой
+ * ошибки компиляции (см. `propsFromSchema.test-d.ts`, кейс «широкая
+ * аннотация до typeof схлопывает generic»). Это известное ограничение
+ * TS-generic-утилит такого рода, а не дефект: штатный путь — необсуждённый
+ * литерал `schema` в TSX-исходнике — с ним не сталкивается.
+ */
+export declare type PropsFromSchema<S extends Record<string, SchemaFieldDescriptor>> = PropsShape<S, true, typeof MAX_SCHEMA_DEPTH>;
+
+/**
+ * Один обход схемы, параметризованный правилом верхнего уровня
+ * (`ConsiderDefault`) — оба публичных представления (`PropsFromSchema`/
+ * `ConsumerPropsFromSchema`) производятся ИМ ЖЕ, а не двумя копиями (Г-07):
+ * разъехавшиеся копии обхода и есть тот второй контракт рядом со значением
+ * по умолчанию, который правило запрещает.
+ *
+ * Ключи разбиваются на обязательные/опциональные через `as`-переотображение
+ * мэппед-типа (стандартный приём разбиения ключей объекта по предикату) и
+ * пересекаются — обязательные без `?`, опциональные с `?`.
+ */
+declare type PropsShape<S extends Record<string, SchemaFieldDescriptor>, ConsiderDefault extends boolean, D extends number> = Simplify<{
+    [K in keyof S as FieldRequired<S[K], ConsiderDefault> extends true ? K : never]: FieldValueType<S[K], D>;
+} & {
+    [K in keyof S as FieldRequired<S[K], ConsiderDefault> extends true ? never : K]?: FieldValueType<S[K], D>;
+}>;
 
 /**
  * Payload для `reachGoal`. Phase 3 НЕ автоинъектит scope-поля
@@ -227,6 +521,38 @@ export declare interface ReachGoalInfo {
     campaignId?: number;
 }
 
+/**
+ * Дескриптор ОДНОГО поля литерала `schema` артефакта (Phase 97, план 97-02,
+ * TYPES-03/04) — форма, которую `PropsFromSchema` видит в TSX-исходнике
+ * артефакта (домен схемы артефакта, не домен уровневых переменных проекта —
+ * см. `ProjectPropertyDescriptor` в `@fragmentsx/fragment-compiler`, форма та
+ * же, но домен другой, и объединять их не нужно: у гейта дескриптор — вход
+ * публичного контракта, здесь — форма литерала в исходнике артефакта).
+ *
+ * `readonly` на всех полях — этот тип используется ТОЛЬКО как параметр
+ * `extends` для generic-вывода (`PropsFromSchema<typeof schema>`), а не как
+ * тип значения, которое мутируется в рантайме.
+ */
+export declare interface SchemaFieldDescriptor {
+    readonly type: VariableType;
+    readonly required?: boolean;
+    readonly defaultValue?: unknown;
+    /** `Enum` — варианты значения; `PropsFromSchema` сужает до `cases[].id`. */
+    readonly cases?: ReadonlyArray<{
+        readonly id: string;
+        readonly name: string;
+    }>;
+    /** `Object` — вложенные поля; та же форма рекурсивно. */
+    readonly fields?: Record<string, SchemaFieldDescriptor>;
+    /** `Array` — дескриптор элемента; та же форма рекурсивно. */
+    readonly definition?: SchemaFieldDescriptor;
+}
+
+/** Разворачивает пересечение мэппед-типов в один плоский объектный тип для читаемых сообщений об ошибках компилятора. */
+declare type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
 /**
  * Ref-counted `<link rel="stylesheet">` injector для compiled fragment CSS delivery (Req #11).
  *
@@ -385,6 +711,105 @@ export declare function useFragmentMetrics(): FragmentMetrics;
 
 export declare function useFragmentStylesheet(href: string, key: string): void;
 
-export declare function useProjectProperty(name: string): unknown;
+export declare function useProjectProperty<K extends keyof ProjectProperties>(name: K): ProjectProperties[K];
+
+/** Носитель типа поля-НЕ-Enum/Object/Array — читает `value`-проекцию таблицы `VARIABLE_TYPE_TO_TS` (носитель, значение не используется, только тип). */
+declare type ValueOfVariableType<T extends VariableType> = (typeof VARIABLE_TYPE_TO_TS)[T]["value"];
+
+/**
+ * Таблица `VariableType → тип TS` (Phase 97, TYPES-02, D-97-03). Живёт в
+ * `packages/definition` — рядом с самим `VariableType` (`constants/index.ts`),
+ * а не в гейте и не в `runtime-react`: `PropsFromSchema` (план 97-02) обязан
+ * быть импортируем артефактом (`@fragmentsx/runtime-react`), а зависимость
+ * `runtime-react → fragment-compiler` недопустима бюджетом бандла (RUNTIME-05).
+ *
+ * НЕ сливать с двумя соседними реестрами `VariableType → valibot-схема`,
+ * живущими в другом домене (домен valibot-дефолтов и домен литеральности
+ * схемы артефакта соответственно) — три таблицы, три домена (D-97-03).
+ * Поимённо и с числом покрытия каждого соседнего реестра — см. докстринг
+ * `variableTypeToTs.test.ts`: это единственное место, где запрет на
+ * слияние виден тому, кто через полгода откроет три похожих объекта и
+ * решит их свести. Обе соседние таблицы разошлись между собой незамеченно
+ * именно потому, что ни одна не была исчерпывающей механически; эта
+ * таблица закрывает исчерпанность компилятором — предикатом полноты в
+ * конце файла, а не глазами.
+ *
+ * `Event`/`Goal`/`ComponentInstance` — `never`: у события и цели значения
+ * нет вовсе, а экземпляр компонента в артефакт не проецируется — `never`
+ * делает попытку прочитать такое свойство ошибкой компиляции вместо тихого
+ * `undefined` в рантайме.
+ */
+declare const VARIABLE_TYPE_TO_TS: {
+    String: {
+        ts: string;
+        value: string;
+    };
+    Link: {
+        ts: string;
+        value: string;
+    };
+    Color: {
+        ts: string;
+        value: string;
+    };
+    Image: {
+        ts: string;
+        value: string;
+    };
+    Date: {
+        ts: string;
+        value: string;
+    };
+    Number: {
+        ts: string;
+        value: number;
+    };
+    Boolean: {
+        ts: string;
+        value: boolean;
+    };
+    Enum: {
+        ts: string;
+        value: string;
+    };
+    Object: {
+        ts: string;
+        value: Record<string, unknown>;
+    };
+    Array: {
+        ts: string;
+        value: unknown[];
+    };
+    Event: {
+        ts: string;
+        value: never;
+    };
+    Goal: {
+        ts: string;
+        value: never;
+    };
+    ComponentInstance: {
+        ts: string;
+        value: never;
+    };
+};
+
+declare type VariableType = keyof typeof variableType;
+
+declare const variableType: {
+    Image: "Image";
+    Link: "Link";
+    Event: "Event";
+    String: "String";
+    Boolean: "Boolean";
+    Array: "Array";
+    Color: "Color";
+    ComponentInstance: "ComponentInstance";
+    Date: "Date";
+    Enum: "Enum";
+    Number: "Number";
+    Object: "Object";
+    Goal: "Goal";
+};
 
 export { }

package/dist/index.es.js

@@ -118,7 +118,10 @@ function J(r, e) {
   H(() => M(r, e), [r, e]);
 }
 const q = parseInt(k.split(".")[0], 10), Q = q >= 19;
-function E({ href: r, fragmentKey: e }) {
+function E({
+  href: r,
+  fragmentKey: e
+}) {
   return Q ? /* @__PURE__ */ l(
     "link",
     {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fragmentsx/runtime-react",
   "private": false,
-  "version": "0.2.0-dev-20260902143145",
+  "version": "0.2.0-dev-20260910122311",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -32,7 +32,7 @@
   },
   "dependencies": {
     "@graph-state/core": "^0.13.3",
-    "@fragmentsx/fragments-client": "0.2.0-dev-20260902143145"
+    "@fragmentsx/fragments-client": "0.2.0-dev-20260910122311"
   },
   "devDependencies": {
     "@testing-library/jest-dom": "^6.6.3",
@@ -45,13 +45,14 @@
     "typescript": "^5.5.4",
     "vite": "^6.1.0",
     "vite-plugin-dts": "^4.5.0",
-    "vitest": "^3.1.1"
+    "vitest": "^3.1.1",
+    "@fragmentsx/definition": "0.2.3"
   },
   "scripts": {
     "clear": "rm -r -f ./dist",
     "build": "vite build",
     "dev": "vite build -w",
-    "test": "vitest run --config ./vitest.config.ts",
+    "test": "NODE_OPTIONS=--max-old-space-size=2048 vitest run --config ./vitest.config.ts",
     "test:watch": "vitest --config ./vitest.config.ts",
     "lint": "eslint . --ext .ts,.tsx --fix"
   }