@endge/core 1.2.5 → 1.2.8

package/dist/domain/types/document/schema.types.d.ts

@@ -0,0 +1,102 @@
+import { Projects_Repository } from '../../../model/db/repositories/Projects_Repository';
+import { Types_Repository } from '../../../model/db/repositories/Types_Repository';
+import { Queries_Repository } from '../../../model/db/repositories/Queries_Repository';
+import { DataViews_Repository } from '../../../model/db/repositories/DataViews_Repository';
+import { Folders_Repository } from '../../../model/db/repositories/Folders_Repository';
+import { Components_Repository } from '../../../model/db/repositories/Components_Repository';
+import { ComponentSFCs_Repository } from '../../../model/db/repositories/ComponentSFCs_Repository';
+import { Actions_Repository } from '../../../model/db/repositories/Actions_Repository';
+import { Vocabs_Repository } from '../../../model/db/repositories/Vocabs_Repository';
+import { I18nBundles_Repository } from '../../../model/db/repositories/I18nBundles_Repository';
+import { AuthProfiles_Repository } from '../../../model/db/repositories/AuthProfiles_Repository';
+import { Parameters_Repository } from '../../../model/db/repositories/Parameters_Repository';
+import { Filters_Repository } from '../../../model/db/repositories/Filters_Repository';
+import { Converters_Repository } from '../../../model/db/repositories/Converters_Repository';
+import { Integrations_Repository } from '../../../model/db/repositories/Integrations_Repository';
+import { Versions_Repository } from '../../../model/db/repositories/Versions_Repository';
+import { PageTemplates_Repository } from '../../../model/db/repositories/PageTemplates_Repository';
+import { Pages_Repository } from '../../../model/db/repositories/Pages_Repository';
+import { Navigations_Repository } from '../../../model/db/repositories/Navigations_Repository';
+import { Environments_Repository } from '../../../model/db/repositories/Environments_Repository';
+import { Policies_Repository } from '../../../model/db/repositories/Policies_Repository';
+import { Styles_Repository } from '../../../model/db/repositories/Styles_Repository';
+import { Tenants_Repository } from '../../../model/db/repositories/Tenants_Repository';
+import { Workspaces_Repository } from '../../../model/db/repositories/Workspaces_Repository';
+import { Compositions_Repository } from '../../../model/db/repositories/Compositions_Repository';
+import { Stores_Repository } from '../../../model/db/repositories/Stores_Repository';
+import { Mocks_Repository } from '../../../model/db/repositories/Mocks_Repository';
+import { Computations_Repository } from '../../../model/db/repositories/Computations_Repository';
+export interface EndgeSchemaDump {
+    workspaces?: any[];
+    workspace?: any;
+    projects: any[];
+    types: any[];
+    queries: any[];
+    dataViews: any[];
+    compositions: any[];
+    stores: any[];
+    mocks: any[];
+    folders: any[];
+    components: any[];
+    componentSFCs: any[];
+    actions: any[];
+    converters: any[];
+    computations: any[];
+    integrations: any[];
+    vocabs: any[];
+    i18nBundles: any[];
+    authProfiles: any[];
+    parameters: any[];
+    filters: any[];
+    versions: any[];
+    environments: any[];
+    tenants: any[];
+    policies: any[];
+    styles: any[];
+    pageTemplates: any[];
+    pages: any[];
+    navigations: any[];
+}
+export type EndgeSchemaErrorKind = 'PAYLOAD_NOT_CONFIGURED' | 'PAYLOAD_PING_FAILED' | 'COLLECTION_UNREACHABLE';
+export interface EndgeSchemaError {
+    kind: EndgeSchemaErrorKind;
+    message: string;
+    collection?: string;
+    details?: any;
+    at: string;
+}
+export type RepositoriesBag = {
+    workspaces?: Workspaces_Repository;
+    projects: Projects_Repository;
+    types: Types_Repository;
+    queries: Queries_Repository;
+    dataViews: DataViews_Repository;
+    compositions: Compositions_Repository;
+    stores: Stores_Repository;
+    mocks: Mocks_Repository;
+    folders: Folders_Repository;
+    components: Components_Repository;
+    componentSFCs: ComponentSFCs_Repository;
+    actions: Actions_Repository;
+    vocabs: Vocabs_Repository;
+    i18nBundles: I18nBundles_Repository;
+    authProfiles: AuthProfiles_Repository;
+    parameters: Parameters_Repository;
+    filters: Filters_Repository;
+    converters: Converters_Repository;
+    computations: Computations_Repository;
+    integrations: Integrations_Repository;
+    versions: Versions_Repository;
+    environments: Environments_Repository;
+    tenants: Tenants_Repository;
+    policies: Policies_Repository;
+    styles: Styles_Repository;
+    pageTemplates: PageTemplates_Repository;
+    pages: Pages_Repository;
+    navigations: Navigations_Repository;
+};
+export interface EndgeSchemaStorageOptions {
+    payloadBaseAPI: string;
+    payloadSecret: string;
+    collectionsToCheck?: string[];
+}

package/dist/domain/types/document/workspace.types.d.ts

@@ -0,0 +1,23 @@
+import { EndgeConfiguration, EndgeLocaleDefinition, EndgeSSEAuthMode, EndgeSSEConfiguration, EndgeThemeDefinition, EndgeVariableDefinition } from '../configuration';
+import { EntityManagement } from './entity-management.type';
+export type EndgeWorkspaceLocale = EndgeLocaleDefinition;
+export type EndgeDataMode = 'live' | 'mock';
+export type EndgeWorkspaceLocaleLabelMode = keyof Pick<EndgeWorkspaceLocale, 'displayName' | 'shortLabel'>;
+export type EndgeWorkspaceTheme = EndgeThemeDefinition;
+export type EndgeWorkspaceSSEAuthMode = EndgeSSEAuthMode;
+export type EndgeWorkspaceVar = EndgeVariableDefinition;
+export type EndgeWorkspaceSSEConfig = EndgeSSEConfiguration;
+export interface WorkspaceIntegrationReference {
+    integrationId: string | number;
+    integrationIdentity: string;
+    version: string;
+}
+export interface EndgeWorkspaceDefinition extends EntityManagement {
+    identity: string;
+    displayName: string;
+    dataMode: EndgeDataMode;
+    meta?: Record<string, unknown>;
+    installedIntegrations: WorkspaceIntegrationReference[];
+    configuration: EndgeConfiguration;
+}
+export type EndgeWorkspaceDefinitionInput = Partial<EndgeWorkspaceDefinition> & Record<string, unknown>;

package/dist/domain/types/{action.types.d.ts → flow/action.types.d.ts}

@@ -1,4 +1,4 @@
-import { ActionRuntimeHostContext } from './runtime-host.types';
+import { ActionRuntimeHostContext } from '../runtime/runtime-host.types';
 import { FlowExecutionState } from './endge-flow-runtime.types';
 import { ActionFlowDefinition } from './endge-flow.types';
 /**

package/dist/domain/types/{endge-flow.types.d.ts → flow/endge-flow.types.d.ts}

@@ -2,7 +2,7 @@
  * Канонический тип шага внутри action-flow.
  * Описывает поведение шага на уровне UX/runtime, а не форму graph-node.
  */
-export type ActionFlowStepKind = 'builtin' | 'behavior-binding' | 'runtime' | 'flow-ref';
+export type ActionFlowStepKind = 'builtin' | 'action' | 'runtime' | 'flow-ref';
 /**
  * Тип graph-node внутри action-flow.
  * Определяет, какой блок должен быть исполнен рантаймом flow.

package/dist/domain/types/flow/index.d.ts

@@ -0,0 +1,4 @@
+export * from './action.types';
+export * from './endge-flow.types';
+export * from './endge-flow-runtime.types';
+export * from './flow-condition.types';

package/dist/domain/types/i18n.types.d.ts

@@ -0,0 +1,23 @@
+export type I18nLocaleMessages = Record<string, unknown>;
+export type I18nLocales = Record<string, I18nLocaleMessages>;
+/** Плоский compiler-derived индекс сообщений одной локали. */
+export type I18nCompiledLocaleMessages = Record<string, string>;
+/** Compiler-derived сообщения одного i18n-документа по локалям. */
+export type I18nCompiledLocales = Record<string, I18nCompiledLocaleMessages>;
+/** Один публичный translation alias в runtime-контексте Composition. */
+export interface I18nRuntimeCatalogEntry {
+    messages: I18nCompiledLocales;
+}
+/** Накопленный translation catalog, доступный дочернему runtime. */
+export type I18nRuntimeCatalog = Record<string, I18nRuntimeCatalogEntry>;
+export interface I18nTranslateOptions {
+    locale?: string;
+    fallbackLocale?: string;
+    bundle?: string;
+    params?: Record<string, unknown>;
+    defaultValue?: string;
+}
+export interface I18nMessagesOptions {
+    bundle?: string;
+    includeInactive?: boolean;
+}

package/dist/domain/types/kernel/bootstrap.types.d.ts

@@ -0,0 +1,48 @@
+import { EndgeExecutionContext } from '../configuration';
+/**
+ * Источник получения доменных данных
+ * default - работа с внешним сервисом backend
+ * payload - @Deprecated внешний сервис на payload
+ * plain - данные подтягиваются из файла
+ */
+export type EndgeDataProvider = 'default' | 'payload' | 'plain';
+/**
+ * Конфигурация загрузки движка
+ * Определяет workspace, данные которого должны быть активированы из Payload.
+ * Tenant, project и environment передаются отдельно через EndgeBootContext.context.
+ */
+export interface EndgeLoadScope {
+    workspaceIdentity?: string;
+}
+export interface EndgePayloadProviderOptions {
+    baseAPI: string;
+    secret: string;
+}
+export interface EndgeBootContext {
+    /**
+     * Источник получения доменных данных
+     */
+    dataProvider: EndgeDataProvider;
+    /**
+     * Граница загружаемых данных.
+     */
+    scope: EndgeLoadScope;
+    /** Structural context immutable for one complete boot/build lifecycle. */
+    context?: Partial<EndgeExecutionContext>;
+    /**
+     * Runtime/env vars, которые нужны ядру.
+     */
+    vars: Record<string, unknown>;
+    /**
+     * Для plain provider.
+     */
+    plainSource?: unknown;
+    /**
+     * Для payload provider.
+     */
+    payload?: EndgePayloadProviderOptions;
+    /**
+     * Для отмены долгой загрузки/сборки.
+     */
+    signal?: AbortSignal;
+}

package/dist/domain/types/kernel/endge-modules.types.d.ts

@@ -0,0 +1,18 @@
+import { EndgeModule } from '../../entities/endge/EndgeModule';
+export type EndgeModuleConstructor<T extends EndgeModule = EndgeModule> = new () => T;
+export interface EndgeModuleDefinition<T extends EndgeModule = EndgeModule> {
+    key: string;
+    module: EndgeModuleConstructor<T>;
+    before?: string | string[];
+    after?: string | string[];
+}
+export interface EndgeModuleDescriptor<T extends EndgeModule = EndgeModule> {
+    key: string;
+    module: T;
+    before?: string | string[];
+    after?: string | string[];
+}
+export interface EndgePlugin {
+    id: string;
+    install(): void;
+}

package/dist/domain/types/kernel/federation.types.d.ts

@@ -0,0 +1,15 @@
+import { EndgeModule } from '../../entities/endge/EndgeModule';
+import { EndgeModuleDescriptor, EndgePlugin } from './endge-modules.types';
+import { EndgeBootContext } from './bootstrap.types';
+export interface EndgeFederationHost {
+    isConfigured: boolean;
+    isConfiguring: boolean;
+    isSetup: boolean;
+    isInitialized: boolean;
+    isHydrating: boolean;
+    bootContext: EndgeBootContext | null;
+    moduleDescriptors: EndgeModuleDescriptor[];
+    modules: Map<string, EndgeModule>;
+    plugins: EndgePlugin[];
+    installedPluginIds: Set<string>;
+}

package/dist/domain/types/kernel/index.d.ts

@@ -0,0 +1,4 @@
+export * from './bootstrap.types';
+export * from './endge-modules.types';
+export * from './events.types';
+export * from './federation.types';

package/dist/domain/types/mock/index.d.ts

@@ -0,0 +1 @@
+export * from './mock-data.type';

package/dist/domain/types/mock/mock-data.type.d.ts

@@ -0,0 +1,37 @@
+import { RMock } from '../../entities/reflect/RMock';
+export type RMockContentSource = 'document' | 'code-provider';
+export type RMockContentType = 'application/json' | 'text/plain';
+/** Контекст вызова code provider для persisted mock-документа. */
+export interface EndgeMockProviderContext {
+    mock: RMock;
+}
+/** Кодовая реализация содержимого, подключаемая к persisted mock по codeRef. */
+export interface EndgeMockProvider {
+    ref: string;
+    description?: string;
+    provide: (context: EndgeMockProviderContext) => unknown;
+}
+/** @deprecated Используйте EndgeMockProvider. */
+export interface EndgeMockRegistration {
+    /** Стабильный identity, используемый в source через mock(identity). */
+    identity: string;
+    /** Исходный mock payload. EndgeMock хранит и возвращает независимые копии. */
+    data: unknown;
+    /** Необязательное описание сценария для diagnostics и configurator UI. */
+    description?: string;
+}
+/** Публичное описание зарегистрированного mock payload без самих данных. */
+export interface EndgeMockDescriptor {
+    ref: string;
+    description?: string;
+}
+export type EndgeMockBindingStatus = 'document' | 'connected' | 'missing-document' | 'missing-provider' | 'invalid-content';
+/** Сериализуемый snapshot модуля EndgeMock. */
+export interface EndgeMockSnapshot {
+    providers: EndgeMockDescriptor[];
+}
+/** Compiler/runtime reference на mock payload. */
+export interface EndgeMockReference {
+    kind: 'mock';
+    identity: string;
+}

package/dist/domain/types/program/index.d.ts

@@ -0,0 +1,2 @@
+export * from './program.types';
+export * from './program-metadata.types';

package/dist/domain/types/program/program-metadata.types.d.ts

@@ -0,0 +1,26 @@
+/** JSON-совместимое значение публичной metadata compiled artifact. */
+export type ProgramMetadataValue = null | boolean | number | string | ProgramMetadataValue[] | {
+    [key: string]: ProgramMetadataValue;
+};
+/** Metadata сущности, сгруппированная по пользовательскому namespace. */
+export type ProgramMetadataMap = Record<string, ProgramMetadataValue>;
+/** Metadata внутреннего source/IR-узла с сохранением provenance. */
+export interface ProgramNodeMetadata {
+    /** Стабильный id узла внутри compiled artifact. */
+    nodeId: string;
+    /** Семантический тип узла, например `Column` или `Text`. */
+    nodeKind: string;
+    /** Пользовательский key узла, если он объявлен в source. */
+    key?: string;
+    /** Metadata узла по namespace. */
+    values: ProgramMetadataMap;
+}
+/** Общий metadata-контракт любого compiled artifact. */
+export interface ProgramMetadata {
+    /** Metadata самой доменной сущности. */
+    self: ProgramMetadataMap;
+    /** Metadata внутренних source/IR-узлов. */
+    nodes: ProgramNodeMetadata[];
+}
+/** Создаёт пустой предсказуемый metadata-контракт artifact. */
+export declare function createEmptyProgramMetadata(): ProgramMetadata;

package/dist/domain/types/program/program.types.d.ts

@@ -0,0 +1,283 @@
+import { ActionCompiledFlow } from '../flow/action.types';
+import { RComponentContract, RComponentDependencies } from '../component/component-core.types';
+import { DataViewManualTransform, DataViewPipelineStep, DataViewRef, DataViewSourceDocument } from '../source/data-view-source.types';
+import { RComponentSFC_AST, RComponentSFC_IR, RComponentSFC_RuntimeDependencies, RComponentSFCSource_Parts } from '../component/sfc';
+import { QueryProgramProp, SourceExpressionIR } from '../source/source-expression.types';
+import { ProgramMetadata } from './program-metadata.types';
+import { ComputationProgramPayload } from '../computation';
+import { EndgeStyleSheetArtifact } from '../style';
+import { ActionImplementation, ActionTargetSelector } from '../runtime/action.types';
+/** Тип доменной сущности, для которой compiler может построить program artifact. */
+export type ProgramEntityType = 'type' | 'component-sfc' | 'computation' | 'action' | 'query' | 'data-view' | 'store' | 'filter' | 'composition' | 'style';
+/** Итоговый статус artifact после компиляции и валидации. */
+export type ProgramArtifactStatus = 'valid' | 'warning' | 'error';
+/** Возможность, которую artifact предоставляет runtime/render слоям. */
+export type ProgramCapability = 'compilable' | 'runnable' | 'executable' | 'renderable' | 'data-provider' | 'configuration';
+/** Стабильная ссылка на compiled artifact внутри Endge.program. */
+export interface ProgramArtifactRef {
+    /** Тип доменной сущности, которой принадлежит artifact. */
+    entityType: ProgramEntityType;
+    /** Persisted id доменной сущности или fallback id, если persisted id еще нет. */
+    id: string | number;
+    /** Стабильная identity доменной сущности для поиска без привязки к database id. */
+    identity: string;
+}
+/** Диагностическое сообщение, полученное во время компиляции artifact. */
+export interface ProgramDiagnostic {
+    /** Уровень важности диагностического сообщения. */
+    severity: 'info' | 'warning' | 'error';
+    /** Машинный код диагностики для фильтрации, тестов и UI-группировки. */
+    code: string;
+    /** Человекочитаемое описание проблемы или предупреждения. */
+    message: string;
+    /** Artifact, к которому относится диагностика. Заполняется при добавлении в program. */
+    entityRef?: ProgramArtifactRef;
+    /** Путь внутри source/model: например script, template, style или definition.nodes. */
+    sourcePath?: string;
+    /** Абсолютный offset начала проблемного фрагмента в source. */
+    start?: number;
+    /** Абсолютный offset конца проблемного фрагмента в source. */
+    end?: number;
+}
+/** Зависимость compiled artifact от другой доменной сущности или внешней capability. */
+export interface ProgramDependency {
+    /** Тип зависимой сущности. Может быть расширен строкой для внешних источников. */
+    entityType: ProgramEntityType | string;
+    /** Id зависимой сущности, если он известен compiler-у. */
+    id: string | number;
+    /** Identity зависимой сущности, если она известна compiler-у. */
+    identity?: string;
+    /** Роль зависимости: child-component, renderer, data-source и т.п. */
+    role?: string;
+}
+/** Единица compiled program: результат компиляции одной доменной сущности. */
+export interface ProgramArtifact<TPayload = unknown> {
+    /** Ссылка на исходную доменную сущность и ключ artifact в program. */
+    ref: ProgramArtifactRef;
+    /** Hash стабильного source-снимка, по которому можно понять, менялся ли artifact input. */
+    sourceHash: string;
+    /** Версия compiler pipeline, построившая artifact. */
+    compilerVersion: string;
+    /** Hash structural context и effective configuration этой сборки. */
+    contextHash?: string;
+    /** Итоговый статус artifact с учетом diagnostics. */
+    status: ProgramArtifactStatus;
+    /** Список diagnostics, привязанных к artifact. */
+    diagnostics: ProgramDiagnostic[];
+    /** Список зависимостей, найденных compiler-ом. */
+    dependencies: ProgramDependency[];
+    /** Возможности artifact для runtime/render/query слоев. */
+    capabilities: ProgramCapability[];
+    /** Публичная compiler-derived metadata сущности и её внутренних узлов. */
+    metadata: ProgramMetadata;
+    /** Typed payload конкретного artifact: SFC IR, compiled flow, query plan и т.п. */
+    payload: TPayload;
+    /** Локальные compiled artifacts, принадлежащие только этому artifact. */
+    children?: ProgramArtifact[];
+}
+/** Payload artifact для action: скомпилированный flow или null при ошибке компиляции. */
+export interface ActionProgramPayload {
+    /** Нормализованный action-flow с индексами и runtime-ready структурой. */
+    compiledFlow: ActionCompiledFlow | null;
+    target: ActionTargetSelector[] | null;
+    input: {
+        type: string;
+        name?: string;
+        isArray?: boolean;
+        optional?: boolean;
+    } | null;
+    output: {
+        type: string;
+        name?: string;
+        isArray?: boolean;
+        optional?: boolean;
+    } | null;
+    implementation: ActionImplementation;
+}
+export type QueryProgramOutputSource = {
+    type: 'response';
+    path: string | null;
+    expression?: import('../source/source-expression.types').SourceExpressionIR;
+} | {
+    type: 'output';
+    key: string;
+};
+export interface QueryProgramOutput {
+    key: string;
+    source: QueryProgramOutputSource;
+    dataViews: DataViewRef[];
+    materialization: {
+        kind: 'source';
+    } | {
+        kind: 'derived';
+        strategy: import('../source/data-view-source.types').DataViewMaterializationStrategy;
+    };
+}
+/** Backward-compatible static value or compiled runtime request expression. */
+export type QueryProgramRequestValue<T> = T | SourceExpressionIR;
+/** Payload artifact для query-сущности. */
+export interface QueryProgramPayload {
+    /** Версия source syntax, определяющая runtime contract. */
+    sourceVersion: number;
+    /** Parser-level AST query source, нужен для diagnostics/debug UI. */
+    ast?: unknown;
+    /** Canonical authoring-модель query source. */
+    sourceDocument?: unknown;
+    /** Тип query: REST, GraphQL, custom или другой поддерживаемый источник. */
+    type: string;
+    /** HTTP method для REST query. */
+    method?: QueryProgramRequestValue<string>;
+    /** Endpoint или базовая ссылка источника данных. */
+    endpoint: QueryProgramRequestValue<string>;
+    /** Тело запроса, GraphQL document или custom query expression. */
+    query: QueryProgramRequestValue<string>;
+    /** Заголовки REST query. */
+    headers?: QueryProgramRequestValue<Record<string, string>>;
+    /** Auth config, подготовленный для runtime query layer. */
+    auth?: QueryProgramRequestValue<unknown>;
+    /** Request timeout для REST query. */
+    timeoutMs?: QueryProgramRequestValue<number>;
+    /** Отправлять body как application/x-www-form-urlencoded. */
+    sendAsFormUrlencoded?: QueryProgramRequestValue<boolean>;
+    /** Единственный runtime input contract Query. */
+    props: QueryProgramProp[];
+    /** Безопасный request.body IR. При null отправляется пустой object payload. */
+    requestBody: SourceExpressionIR | null;
+    /** Включены ли mock data для query. */
+    mockDataEnabled?: boolean;
+    /** Mock payload query. */
+    mockData?: unknown;
+    /** Ordered output graph, который runtime вычисляет после backend response. */
+    outputs: QueryProgramOutput[];
+}
+/** Payload artifact для DataView: executable read-model без persisted runtime state. */
+export interface DataViewProgramPayload {
+    /** Тип artifact для diagnostics/debug UI. */
+    type: 'data-view';
+    /** Режим выполнения source: manual transform, pipeline, object projection или root expression. */
+    mode: 'manual' | 'pipeline' | 'projection' | 'expression';
+    /** Runtime-ready strategy; auto всегда разрешен compiler-ом заранее. */
+    materializationStrategy: import('../source/data-view-source.types').DataViewMaterializationStrategy;
+    /** Canonical source document для debug/preview UI. */
+    sourceDocument: DataViewSourceDocument | null;
+    /** Compiled manual transform. Используется только в mode=manual. */
+    transform: DataViewManualTransform | null;
+    /** Compiled pipeline steps. Используется только в mode=pipeline. */
+    steps: DataViewPipelineStep[];
+    /** Compiled object fields. Используется только в mode=projection. */
+    output: Record<string, SourceExpressionIR>;
+    /** Compiled root expression. Используется только в mode=expression. */
+    expression?: SourceExpressionIR | null;
+}
+/** Payload artifact для нового source-first SFC компонента. */
+export interface ComponentSFCProgramPayload {
+    /** Independent compiler status for each SFC section. */
+    sections?: Record<'script' | 'template' | 'style', ProgramArtifactStatus>;
+    /** Разложенный canonical source: script, template и style. */
+    sourceParts: RComponentSFCSource_Parts;
+    /** Внешний контракт компонента: inputs, events, slots. */
+    contract: RComponentContract;
+    /** Зависимости компонента: дочерние компоненты, data sources, actions, renderers. */
+    dependencies: RComponentDependencies;
+    /** Runtime-зависимости SFC v1, по которым host подписывается на input source. */
+    runtimeDependencies: RComponentSFC_RuntimeDependencies;
+    /** Preview-only props для песочницы/debug UI. Не являются runtime default props. */
+    previewProps: ComponentSFCPreviewProps | null;
+    /** Preview-only runtime options: seed local store, run queries/actions etc. */
+    previewOptions: ComponentSFCPreviewOptions | null;
+    /** Parser-level AST SFC source, нужен для diagnostics и debug UI. */
+    ast: RComponentSFC_AST | null;
+    /** Target-neutral semantic IR, который renderer-слои используют для DOM/Nova. */
+    ir: RComponentSFC_IR | null;
+}
+/** Runtime payload source-first style document. */
+export interface EndgeStyleProgramPayload {
+    /** Renderer-neutral compiled stylesheet. */
+    stylesheet: EndgeStyleSheetArtifact;
+    /** Theme ids contributed by this document. */
+    themes: string[];
+    /** External dependencies discovered while compiling style conditions. */
+    dependencies: ProgramDependency[];
+}
+export type { ComputationProgramPayload };
+/** Одна запись build-derived registry пользовательских SFC tags. */
+export interface ComponentSFCTagRegistryEntry {
+    /** Пользовательский tag, доступный в template. */
+    tag: string;
+    /** Identity persisted SFC-компонента, на который разрешается tag. */
+    identity: string;
+}
+export type ComponentSFCPreviewLiteral = null | string | number | boolean | ComponentSFCPreviewLiteral[] | {
+    [key: string]: ComponentSFCPreviewLiteral;
+};
+export interface ComponentSFCPreviewStoreProp {
+    type: 'store';
+    path: string;
+}
+export interface ComponentSFCPreviewDataProp {
+    type: 'data';
+    store: string;
+    path: string;
+}
+export type ComponentSFCPreviewPropValue = ComponentSFCPreviewLiteral | ComponentSFCPreviewStoreProp | ComponentSFCPreviewDataProp;
+export type ComponentSFCPreviewProps = Record<string, ComponentSFCPreviewPropValue>;
+export interface ComponentSFCPreviewRunTarget {
+    type: 'query';
+    identity: string;
+    storeTo?: {
+        store: string;
+        fields: Record<string, string>;
+    };
+}
+export interface ComponentSFCPreviewOptions {
+    seed?: Record<string, ComponentSFCPreviewLiteral>;
+    run?: ComponentSFCPreviewRunTarget[];
+}
+/** Контекст одного запуска compiler pipeline. */
+export interface ProgramCompileContext {
+    /** Версия compiler pipeline, которая попадет во все artifacts текущей сборки. */
+    compilerVersion: string;
+    /** Immutable structural context and effective configuration of this build. */
+    buildContext: import('../configuration').EndgeBuildContext;
+}
+/** Handler компиляции одного типа доменных сущностей. */
+export interface EntityCompilerHandler<TEntity = unknown, TPayload = unknown> {
+    /** Тип сущности, которую умеет компилировать handler. */
+    entityType: ProgramEntityType;
+    /** Функция компиляции одной сущности в один typed artifact. */
+    compile: (entity: TEntity, context: ProgramCompileContext) => ProgramArtifact<TPayload>;
+}
+/** Сводный snapshot текущего Endge.program для diagnostics/debug UI. */
+export interface EndgeProgramSnapshot {
+    /** Unix timestamp создания snapshot. */
+    generatedAt: number;
+    /** Общий статус program, агрегированный по всем artifacts. */
+    status: ProgramArtifactStatus;
+    /** Версия compiler, которой была собрана текущая program. */
+    compilerVersion: string;
+    /** Общее количество artifacts в program. */
+    total: number;
+    /** Количество artifacts по статусам valid/warning/error. */
+    byStatus: Record<ProgramArtifactStatus, number>;
+    /** Количество artifacts по типам доменных сущностей. */
+    byEntityType: Record<string, number>;
+    /** Все diagnostics из всех artifacts. */
+    diagnostics: ProgramDiagnostic[];
+    /** Компактные сведения по каждому artifact без тяжелого payload. */
+    artifacts: Array<{
+        /** Ссылка на artifact. */
+        ref: ProgramArtifactRef;
+        /** Итоговый статус artifact. */
+        status: ProgramArtifactStatus;
+        /** Количество diagnostics у artifact. */
+        diagnostics: number;
+        /** Количество зависимостей у artifact. */
+        dependencies: number;
+        /** Возможности artifact. */
+        capabilities: ProgramCapability[];
+        /** Hash source input artifact. */
+        sourceHash: string;
+        /** Версия compiler, построившая artifact. */
+        compilerVersion: string;
+    }>;
+}