@endge/core 1.2.5 → 1.2.7

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;
+    }>;
+}

package/dist/domain/types/runtime/action.types.d.ts

@@ -0,0 +1,144 @@
+import { EntityOrigin, EntityRef } from '../document/entity-management.type';
+export type RuntimeActionId = string;
+export type RuntimeActionSurface = string;
+/** Stable identities of targetless Actions provided by Endge itself. */
+export declare const BUILTIN_ACTION_IDS: {
+    readonly consoleLog: "built-in-console-log";
+};
+/** Declarative reference accepted by interactive primitives such as MenuItem. */
+export interface ActionBinding<TInput = unknown> {
+    identity: RuntimeActionId;
+    input?: TInput;
+}
+/** One allowed target shape. Multiple selectors are alternatives. */
+export interface ActionTargetSelector {
+    type: string;
+    identity?: string;
+}
+/** Concrete runtime target. Database ids are intentionally not part of the contract. */
+export interface ActionExecutionTarget<TValue = unknown> {
+    type: string;
+    identity: string;
+    value: TValue;
+}
+/** How an Action is executed when there is no higher-priority runtime binding. */
+export type ActionImplementation = {
+    kind: 'flow';
+} | {
+    kind: 'provider';
+    providerKey: string;
+} | {
+    kind: 'component-port';
+    portName: string;
+};
+export interface ActionDefinitionInput {
+    identity: string;
+    displayName?: string;
+    description?: string | null;
+    active?: boolean;
+    target?: ActionTargetSelector[] | null;
+    input?: unknown;
+    output?: unknown;
+    defaultImplementation?: ActionImplementation;
+    owner?: EntityRef;
+}
+export interface ActionExecuteOptions<TInput = unknown> {
+    input?: TInput;
+    target?: ActionExecutionTarget;
+    context?: Record<string, unknown>;
+    resolution?: Partial<Record<Exclude<ImplementationBindingScope, 'default'>, string>>;
+    providerKey?: string;
+}
+export interface ResolvedActionDescriptor {
+    identity: string;
+    displayName: string;
+    description: string | null;
+    active: boolean;
+    origin: EntityOrigin;
+    /** Runtime catalog placement; it does not affect ownership or persistence. */
+    catalogPath?: string[];
+    owner?: EntityRef;
+    target: ActionTargetSelector[] | null;
+    input: unknown | null;
+    output: unknown | null;
+    defaultImplementation: ActionImplementation;
+    overridden: boolean;
+    effectiveProviderKey: string | null;
+    effectiveProviderOrigin: EntityOrigin | null;
+    bindingScope: ImplementationBindingScope | null;
+}
+export type ImplementationBindingScope = 'default' | 'application' | 'workspace' | 'composition' | 'component' | 'invocation';
+/** Renderer-neutral context passed to a runtime Action provider. */
+export interface RuntimeActionContext {
+    surface: RuntimeActionSurface;
+    runtimeId?: string;
+    target?: unknown;
+}
+/** Callable runtime behavior. Unlike Event, Action has one provider and may return a result. */
+export interface RuntimeAction<TContext extends RuntimeActionContext = RuntimeActionContext, TPayload = unknown, TResult = void> {
+    id: RuntimeActionId;
+    label?: string;
+    description?: string;
+    surface?: RuntimeActionSurface;
+    canExecute?: (context: TContext, payload?: TPayload) => boolean;
+    execute: (context: TContext, payload?: TPayload) => TResult | Promise<TResult>;
+}
+export type AnyRuntimeAction = RuntimeAction<any, any, any>;
+export interface RuntimeActionSnapshotItem {
+    id: RuntimeActionId;
+    label?: string;
+    description?: string;
+    surface?: RuntimeActionSurface;
+}
+export interface RuntimeActionRegistrySnapshot {
+    actions: RuntimeActionSnapshotItem[];
+}
+export type TableColumnPinSide = 'left' | 'right' | 'none';
+export type TableSortDirection = 'asc' | 'desc';
+export type TableSortMode = 'multiple' | 'single' | 'fixed' | 'disabled';
+export declare const TABLE_RUNTIME_ACTION_IDS: {
+    readonly columnHide: "table.column.hide";
+    readonly columnPinLeft: "table.column.pinLeft";
+    readonly columnPinRight: "table.column.pinRight";
+    readonly columnUnpin: "table.column.unpin";
+    readonly columnResetPin: "table.column.resetPin";
+    readonly columnResetAllPins: "table.column.resetAllPins";
+    readonly sortSetColumnAsc: "table.sort.setColumnAsc";
+    readonly sortSetColumnDesc: "table.sort.setColumnDesc";
+    readonly sortClearColumn: "table.sort.clearColumn";
+    readonly sortClearAll: "table.sort.clearAll";
+};
+export type TableRuntimeActionId = typeof TABLE_RUNTIME_ACTION_IDS[keyof typeof TABLE_RUNTIME_ACTION_IDS];
+export interface TableColumnSortState {
+    active: boolean;
+    direction?: TableSortDirection;
+    index?: number;
+}
+/** Operations implemented by one mounted Table instance. */
+export interface TableRuntimeActionTarget {
+    setColumnVisibility?: (columnKey: string, visible: boolean) => void | Promise<void>;
+    setColumnPin?: (columnKey: string, side: TableColumnPinSide) => void | Promise<void>;
+    resetColumnPin?: (columnKey: string) => void | Promise<void>;
+    resetAllPins?: () => void | Promise<void>;
+    setColumnSort?: (columnKey: string, direction: TableSortDirection) => void | Promise<void>;
+    clearColumnSort?: (columnKey: string) => void | Promise<void>;
+    clearAllSort?: () => void | Promise<void>;
+}
+export interface TableColumnActionContext extends RuntimeActionContext {
+    surface: 'table-column-header';
+    tableRuntimeId: string;
+    tableId: string;
+    target: TableRuntimeActionTarget;
+    columnKey: string;
+    columnIndex: number;
+    hideable: boolean;
+    pinnable: boolean;
+    pinMode: 'enabled' | 'disabled';
+    pinState: TableColumnPinSide;
+    defaultPinState: TableColumnPinSide;
+    hasPinChanges: boolean;
+    sortable: boolean;
+    sortMode: TableSortMode;
+    sortState: TableColumnSortState;
+    activeSortCount: number;
+}

package/dist/domain/types/runtime/context-persistence.types.d.ts

@@ -0,0 +1,41 @@
+export type EndgePersistenceDriver = 'local' | 'disabled';
+export interface EndgePersistenceOptions {
+    driver?: EndgePersistenceDriver;
+}
+export interface EndgePersistenceScope {
+    workspaceId: string;
+    tenantId: string;
+    projectId: string;
+    environmentId: string;
+    userId: string;
+}
+export interface EndgeSessionIdentity {
+    userId?: string | null;
+    tenantId?: string | null;
+}
+export interface EndgeSessionIdentityProvider {
+    getCurrentIdentity(): EndgeSessionIdentity | null;
+}
+export interface EndgeStorageAdapter {
+    readonly id: EndgePersistenceDriver;
+    isAvailable(): boolean;
+    read<T>(key: string): T | undefined;
+    write<T>(key: string, value: T): void;
+    remove(key: string): void;
+}
+export interface RuntimeStateDocument {
+    version: 1;
+    scope: EndgePersistenceScope;
+    runtimeId: string;
+    state: Record<string, Record<string, unknown>>;
+}
+export interface RuntimeStateControllerLike {
+    readonly runtimeId: string;
+    readonly storageId: string;
+    readonly storageKey: string;
+    readonly scope: EndgePersistenceScope;
+    get<T>(entityKey: string, section: string, fallback: T): T;
+    set<T>(entityKey: string, section: string, value: T): void;
+    remove(entityKey: string, section?: string): void;
+    clear(): void;
+}

package/dist/domain/types/runtime/implementation.types.d.ts

@@ -0,0 +1,59 @@
+import { EntityOrigin } from '../document/entity-management.type';
+import { ActionExecutionTarget, ActionTargetSelector, ImplementationBindingScope } from './action.types';
+export interface ImplementationContract {
+    target?: ActionTargetSelector[] | null;
+    input?: unknown | null;
+    output?: unknown | null;
+}
+export interface ImplementationExecutableRef {
+    type: string;
+    identity: string;
+    value?: unknown;
+}
+export interface ImplementationInvocation<TInput = unknown> {
+    executable: ImplementationExecutableRef;
+    input?: TInput;
+    target?: ActionExecutionTarget;
+    context?: Record<string, unknown>;
+}
+export interface ImplementationProvider<TInput = unknown, TResult = unknown> {
+    key: string;
+    origin: EntityOrigin;
+    active?: boolean;
+    contract?: ImplementationContract;
+    canExecute?: (invocation: ImplementationInvocation<TInput>) => boolean;
+    execute: (invocation: ImplementationInvocation<TInput>) => TResult | Promise<TResult>;
+}
+export interface ImplementationBinding {
+    executableType: string;
+    executableIdentity: string;
+    providerKey: string;
+    scope: Exclude<ImplementationBindingScope, 'default'>;
+    scopeIdentity?: string;
+    priority?: number;
+}
+export interface ImplementationResolutionRequest {
+    executable: ImplementationExecutableRef;
+    defaultProviderKey: string | null;
+    scopeIdentities?: Partial<Record<Exclude<ImplementationBindingScope, 'default'>, string>>;
+    invocationProviderKey?: string;
+    expectedContract?: ImplementationContract;
+}
+export interface ResolvedImplementation {
+    provider: ImplementationProvider;
+    binding: ImplementationBinding | null;
+    scope: ImplementationBindingScope;
+}
+export interface ImplementationSnapshot {
+    providers: Array<{
+        key: string;
+        active: boolean;
+        origin: EntityOrigin;
+    }>;
+    bindings: ImplementationBinding[];
+}
+export type ImplementationDiagnosticCode = 'implementation-provider-missing' | 'implementation-provider-inactive' | 'implementation-binding-ambiguous' | 'implementation-cannot-execute' | 'implementation-contract-incompatible';
+export declare class ImplementationError extends Error {
+    readonly code: ImplementationDiagnosticCode;
+    constructor(code: ImplementationDiagnosticCode, message: string);
+}

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

@@ -0,0 +1,16 @@
+export * from './action.types';
+export * from './implementation.types';
+export * from './context-persistence.types';
+export * from './query-execution.types';
+export * from './runtime-entity-map.types';
+export * from './runtime-host.types';
+export * from './runtime-execute.type';
+export * from './runtime-registry.types';
+export * from './runtime-resource.types';
+export * from './runtime-scope.types';
+export * from './sfc-render-inspection.type';
+export * from './runtime-project-session.types';
+export * from './runtime-strategy.types';
+export * from './runtime.types';
+export * from './table-binding.types';
+export * from './table.types';

package/dist/domain/types/runtime/query-execution.types.d.ts

@@ -0,0 +1,10 @@
+import { QueryProgramPayload } from '../program/program.types';
+/** Runtime context одного выполнения compiled query artifact. */
+export interface QueryExecutionContext {
+    /** Runtime-ready query payload из Endge.program. */
+    payload: QueryProgramPayload;
+    /** Входные параметры одноразового или реактивного запуска. */
+    vars?: Record<string, unknown>;
+    /** AbortSignal текущего runtime run. */
+    signal?: AbortSignal;
+}

package/dist/domain/types/runtime/runtime-entity-map.types.d.ts

@@ -0,0 +1,31 @@
+import { RAction } from '../../entities/reflect/RAction';
+import { RComponentSFC } from '../../entities/reflect/RComponentSFC';
+import { RPage } from '../../entities/reflect/RPage';
+import { RProject } from '../../entities/reflect/RProject';
+import { RQuery } from '../../entities/reflect/RQuery';
+import { RFilter } from '../../entities/reflect/RFilter';
+import { RComposition } from '../../entities/reflect/RComposition';
+import { RStore } from '../../entities/reflect/RStore';
+/**
+ * Канонический перечень сущностей, для которых может существовать runtime-host.
+ */
+export interface RuntimeEntityModelMap {
+    /** Доменная модель проекта. */
+    project: RProject;
+    /** Доменная модель страницы. */
+    page: RPage;
+    /** Доменная модель SFC-компонента нового API. */
+    'component-sfc': RComponentSFC;
+    /** Доменная модель запроса. */
+    query: RQuery;
+    /** Source-first Filter runtime. */
+    filter: RFilter;
+    /** Runtime orchestration graph. */
+    composition: RComposition;
+    /** Source-first reactive Store runtime. */
+    store: RStore;
+    /** Доменная модель action. */
+    action: RAction;
+}
+/** Дискриминатор типа runtime-сущности. */
+export type RuntimeEntityType = keyof RuntimeEntityModelMap;

package/dist/domain/types/runtime/runtime-execute.type.d.ts

@@ -0,0 +1,27 @@
+import { RuntimeAppScope } from '../../entities/runtime/RuntimeAppScope';
+import { EndgePersistenceDriver } from './context-persistence.types';
+import { RuntimeArtifactReader } from './runtime-host.types';
+import { AnyRuntimeHost } from './runtime-strategy.types';
+/** Допустимая ссылка на зарегистрированный родительский runtime-host. */
+export type RuntimeParentRef = AnyRuntimeHost | string;
+/** Типизированные параметры создания runtime-host. */
+export interface RuntimeExecuteOptions {
+    /** Явный runtime-id вместо автоматически выделенного адреса. */
+    id?: string;
+    /** Локальный id экземпляра внутри app scope. */
+    instanceId?: string;
+    /** Зарегистрированный родительский host или его runtime-id. */
+    parent?: RuntimeParentRef | null;
+    /** App scope или id зарегистрированного app scope. */
+    appScope?: RuntimeAppScope | string;
+    /** Read-only источник compiled artifacts. */
+    artifactReader?: RuntimeArtifactReader;
+    /** Политика persistence для runtime state. */
+    persistence?: EndgePersistenceDriver;
+    /** Стабильный storage-id для persisted runtime state. */
+    persistenceKey?: string;
+    /** Strategy-specific metadata, не участвующая в создании runtime tree. */
+    meta?: Record<string, unknown>;
+}
+/** Параметры запуска host через конкретный app scope. */
+export type RuntimeAppScopeExecuteOptions = Omit<RuntimeExecuteOptions, 'appScope'>;