@endge/core 4.0.3 → 6.0.0

package/dist/features/core/modules/runtime/domain/runtime-host.types.d.ts

@@ -0,0 +1,380 @@
+import { PhaseEvent, PhaseName, RaphFrameContext, RaphNode } from '../../../../../../../@endge-raph/dist/main.d.ts';
+import { RuntimeStateControllerLike } from '../../context/domain/context-persistence.types';
+import { ProgramArtifact, ProgramEntityType } from '../../program/domain/types/program.types';
+import { RuntimeEntityModelMap, RuntimeEntityType } from './runtime-entity-map.types';
+import { RuntimeKind } from './runtime.types';
+export type RuntimeHostStatus = 'created' | 'mounted' | 'running' | 'active' | 'pausing' | 'paused' | 'stopping' | 'stopped' | 'unmounted' | 'destroyed' | 'error';
+/** Возможность, которую runtime-host предоставляет внешним consumers. */
+export type RuntimeHostCapability = 'renderable';
+export type RuntimeHostResourceKind = 'raph-node' | 'event-subscription' | 'scope' | 'meta';
+export interface RuntimeHostResource {
+    /** Уникальный идентификатор ресурса внутри host. */
+    id: string;
+    /** Тип ресурса (raph-node, binding, contract и т.д.). */
+    kind: RuntimeHostResourceKind;
+    /** Короткий заголовок для UI/инспектора. */
+    title: string;
+    /** Дополнительная подпись для контекста. */
+    subtitle?: string;
+    /** Произвольные метаданные ресурса. */
+    payload?: Record<string, unknown>;
+}
+export type RuntimeHostChannelKind = 'raph' | 'event-bus' | 'external';
+export interface RuntimeHostChannel {
+    /** Уникальный идентификатор канала. */
+    id: string;
+    /** Семантический тип канала коммуникации. */
+    kind: RuntimeHostChannelKind;
+    /** Отображаемое имя канала. */
+    name: string;
+    /** Направление потока сообщений для канала. */
+    direction: 'in' | 'out' | 'both';
+    /** Дополнительная поясняющая подпись. */
+    subtitle?: string;
+}
+export interface RuntimeHostContextBase {
+    status: 'idle' | 'running' | 'success' | 'error';
+    startedAt: string | null;
+    updatedAt: string | null;
+}
+export interface ActionRuntimeHostContext extends RuntimeHostContextBase {
+    /** Неизменяемый вход текущего вызова Action из Source. */
+    input: Record<string, unknown>;
+    result: unknown;
+    parent?: ActionRuntimeHostContext | null;
+}
+export interface QueryRuntimeHostContext extends RuntimeHostContextBase {
+    lastFilterChangeAt: string | null;
+}
+export interface FilterRuntimeHostContext extends RuntimeHostContextBase {
+    instance: string;
+    lastStateChangeAt: string | null;
+}
+export interface CompositionRuntimeHostContext extends RuntimeHostContextBase {
+    mountedChildren: number;
+    lastHookAt: string | null;
+}
+export interface StoreRuntimeHostContext extends RuntimeHostContextBase {
+    lastStateChangeAt: string | null;
+    writableFields: string[];
+    derivedFields: string[];
+}
+export interface StreamRuntimeHostContext extends RuntimeHostContextBase {
+    lastEventAt: string | null;
+    receivedCount: number;
+}
+export interface ComponentSFCRuntimeHostContext extends RuntimeHostContextBase {
+    /** Target последней подготовки SFC. */
+    target: 'dom' | 'canvas' | null;
+    /** Время последнего разбора source на вкладки. */
+    lastParseAt: string | null;
+    /** Время последней подготовки compiler placeholders. */
+    lastCompileAt: string | null;
+    /** Время последней попытки render/projection. */
+    lastRenderAt: string | null;
+}
+export interface PageRuntimeHostContext extends RuntimeHostContextBase {
+    lastRenderAt: string | null;
+}
+export interface ProjectRuntimeHostContext extends RuntimeHostContextBase {
+    lastRefreshAt: string | null;
+}
+export interface RuntimeHostContextMap {
+    'action': ActionRuntimeHostContext;
+    'query': QueryRuntimeHostContext;
+    'filter': FilterRuntimeHostContext;
+    'composition': CompositionRuntimeHostContext;
+    'store': StoreRuntimeHostContext;
+    'stream': StreamRuntimeHostContext;
+    'component-sfc': ComponentSFCRuntimeHostContext;
+    'page': PageRuntimeHostContext;
+    'project': ProjectRuntimeHostContext;
+}
+export type RuntimeHostContext<TType extends RuntimeEntityType> = RuntimeHostContextMap[TType];
+export interface RuntimeHostSnapshot {
+    /** Идентификатор runtime-host. */
+    id: string;
+    /** Публичный runtime-scoped путь данных host в Raph. */
+    basePath: string;
+    /** Runtime-id родительского host, если host запущен как дочерний. */
+    parentId: string | null;
+    /** Время удаления host, если snapshot попал в debug-архив удалённых. */
+    removedAt: number | null;
+    /** Технический тип runtime-host реализации. */
+    runtimeType: string;
+    /** Возможности runtime-host, доступные внешним consumers. */
+    capabilities: RuntimeHostCapability[];
+    /** Тип доменной сущности, к которой привязан host. */
+    entityType: RuntimeEntityType;
+    /** Identity доменной сущности. */
+    entityIdentity: string;
+    /** Заголовок host для отображения в UI. */
+    title: string;
+    /** Текущий статус жизненного цикла host. */
+    status: RuntimeHostStatus;
+    /** Время создания host (timestamp ms). */
+    createdAt: number;
+    /** Время последнего изменения host (timestamp ms). */
+    updatedAt: number;
+    /** Список ресурсов, связанных с host. */
+    resources: RuntimeHostResource[];
+    /** Список каналов, через которые host взаимодействует с окружением. */
+    channels: RuntimeHostChannel[];
+    /** Произвольные метаданные host. */
+    meta: Record<string, unknown>;
+    /** Контекст host (для debug/inspection). */
+    context: Record<string, unknown>;
+}
+/** Лёгкий архивный описатель. Runtime-данные намеренно исключены. */
+export interface DestroyedRuntimeHostSnapshot {
+    id: string;
+    basePath: string;
+    parentId: string | null;
+    runtimeType: string;
+    capabilities: RuntimeHostCapability[];
+    entityType: RuntimeEntityType;
+    entityIdentity: string;
+    title: string;
+    previousStatus: RuntimeHostStatus;
+    status: 'destroyed';
+    createdAt: number;
+    updatedAt: number;
+    removedAt: number;
+    resources: Array<Omit<RuntimeHostResource, 'payload'>>;
+    channels: RuntimeHostChannel[];
+}
+export interface RuntimeInspectionLease {
+    release: () => void;
+}
+export interface RuntimeHostLifecycle {
+    /** Точка входа совместимости: mount и start. */
+    create: () => Promise<void> | void;
+    mount: () => Promise<void> | void;
+    start: () => Promise<void> | void;
+    pause: () => Promise<void> | void;
+    resume: () => Promise<void> | void;
+    reconcile: () => Promise<void> | void;
+    stop: () => Promise<void> | void;
+    unmount: () => Promise<void> | void;
+    /** Синхронно запрещает новые updates перед освобождением runtime tree. */
+    quiesce: () => Promise<void> | void;
+    /** Корректно остановить host и освободить ресурсы. */
+    destroy: () => Promise<void> | void;
+    /** Обработать runtime update, пришедший из логической либо boundary Raph-фазы. */
+    update: (ctx: RuntimeHostUpdateContext) => Promise<void> | void;
+}
+export interface RuntimeArtifactReader {
+    getArtifact: <TPayload = unknown>(entityType: ProgramEntityType, idOrIdentity: string | number) => ProgramArtifact<TPayload> | null;
+}
+export interface RuntimeHostArtifactRef {
+    entityType: ProgramEntityType;
+    id?: string | number;
+    identity?: string;
+}
+/** Каноническое имя Raph-фазы, которая агрегирует dirty runtime-ноды к root host. */
+export declare const RUNTIME_BOUNDARY_UPDATE_PHASE_NAME: PhaseName;
+/** Фаза логического обновления root-ноды runtime-host. */
+export declare const RUNTIME_NODE_UPDATE_PHASE_NAME: PhaseName;
+/** Значение входа runtime-host: literal либо прямая ссылка на Raph data path. */
+export type RuntimeHostInputBinding = {
+    kind: 'literal';
+    value: unknown;
+} | {
+    kind: 'raph';
+    path: string;
+};
+/** Декларативная команда, которую host должен обработать при изменении sourcePath. */
+export interface RuntimeHostUpdateBinding {
+    id: string;
+    sourcePath: string;
+    update: {
+        kind: string;
+        payload?: unknown;
+    };
+    policy?: {
+        debounceMs?: number;
+    };
+}
+/** Конкретное логическое обновление, разрешённое из Raph events. */
+export interface RuntimeHostResolvedUpdate {
+    bindingId: string;
+    sourcePath: string;
+    kind: string;
+    payload?: unknown;
+}
+/** Локальный input source runtime-host-а без привязки к Raph. */
+export interface RuntimeHostLocalInputSource {
+    kind: 'local';
+    props: Record<string, unknown>;
+}
+/** Binding входного prop на путь в Raph data storage. */
+export interface RuntimeHostRaphInputBinding {
+    path: string;
+    wildcardDynamic?: boolean;
+}
+/** Raph-backed input source runtime-host-а. */
+export interface RuntimeHostRaphInputSource {
+    kind: 'raph';
+    bindings: Record<string, RuntimeHostRaphInputBinding>;
+    /** Literal props, которые объединяются с Raph bindings. */
+    props?: Record<string, unknown>;
+}
+/** Унифицированный источник входных данных runtime-host-а. */
+export type RuntimeHostInputSource = RuntimeHostLocalInputSource | RuntimeHostRaphInputSource;
+/** Группа dirty-ноды, агрегированная к runtime boundary. */
+export interface RuntimeDirtyBoundary {
+    boundary: RaphNode;
+    dirtyNodes: RaphNode[];
+    events: PhaseEvent[];
+}
+/** Контекст универсального runtime update, который получает root runtime-host. */
+export interface RuntimeHostUpdateContext {
+    node: RaphNode;
+    events: PhaseEvent[];
+    boundaries: RuntimeDirtyBoundary[];
+    frame: RaphFrameContext;
+    /** Логические обновления root runtime-ноды. Boundary-фаза это поле не заполняет. */
+    updates?: RuntimeHostResolvedUpdate[];
+}
+/** Проекция patchable collection boundary, которую можно обновить точечно. */
+export interface RuntimeCollectionProjectionPatch {
+    /** Boundary-id дочерней проекции, например колонки таблицы. */
+    boundaryId: string;
+    /** Семантический ключ проекции, например key колонки. */
+    key: string;
+    /** Индекс проекции в render target, например индекс колонки. */
+    index: number;
+}
+/** Patch обновления части коллекции внутри runtime boundary. */
+export interface RuntimeCollectionProjectionUpdatePatch {
+    /** Тип patch payload. */
+    kind: 'collection-projection-update';
+    /** Boundary-id владельца коллекции, например Table. */
+    boundaryId: string;
+    /** Тип boundary владельца коллекции. */
+    boundaryType: 'table';
+    /** Source path, на который подписана boundary-нода. */
+    sourcePath: string;
+    /** Индекс элемента коллекции, если его можно извлечь из Raph event path. */
+    itemIndex: number | null;
+    /** Ключ элемента коллекции, если runtime смог его прочитать. */
+    itemKey: unknown;
+    /** Снимок элемента коллекции после изменения. */
+    itemSnapshot: unknown;
+    /** Измененные относительные paths внутри элемента коллекции. */
+    changedPaths: string[][];
+    /** Проекции, которые зависят от измененных paths. */
+    affectedProjections: RuntimeCollectionProjectionPatch[];
+    /** Исходные события Raph, из которых собран patch. */
+    events: PhaseEvent[];
+    /** Raph-нода, которая стала верхней dirty boundary. */
+    node: RaphNode;
+}
+/** Одно keyed изменение строки внутри пакетного patch коллекции. */
+export interface RuntimeCollectionItemPatch {
+    /** Текущий индекс строки; null означает, что строка удалена из результата. */
+    itemIndex: number | null;
+    /** Стабильный ключ строки из selector или актуального snapshot. */
+    itemKey: unknown;
+    /** Актуальный snapshot строки; null/undefined означает удаление. */
+    itemSnapshot: unknown;
+    /** Измененные относительные paths внутри строки. */
+    changedPaths: string[][];
+}
+/** Пакет keyed изменений одной коллекции за один Raph frame. */
+export interface RuntimeCollectionProjectionBatchPatch {
+    kind: 'collection-projection-batch';
+    boundaryId: string;
+    boundaryType: 'table';
+    sourcePath: string;
+    items: RuntimeCollectionItemPatch[];
+    affectedProjections: RuntimeCollectionProjectionPatch[];
+    events: PhaseEvent[];
+    node: RaphNode;
+}
+/** Нейтральный patch runtime boundary для render adapter-а. */
+export type RuntimeBoundaryPatch = RuntimeCollectionProjectionUpdatePatch | RuntimeCollectionProjectionBatchPatch;
+export interface RuntimeHost<TType extends RuntimeEntityType = RuntimeEntityType, TContext extends RuntimeHostContext<TType> = RuntimeHostContext<TType>, TArtifactPayload = unknown> extends RuntimeHostLifecycle {
+    /** Уникальный runtime-id host. */
+    readonly id: string;
+    /** Родительский runtime-host для отладки вложенных запусков. */
+    readonly parent: RuntimeHost<any, any> | null;
+    /** Канонический runtime kind (query/table/action/runtime). */
+    readonly kind: RuntimeKind | 'runtime';
+    /**
+     * Имя конкретной runtime-реализации host.
+     */
+    readonly runtimeType: string;
+    /** Возможности runtime-host, доступные внешним consumers. */
+    readonly capabilities: readonly RuntimeHostCapability[];
+    /** Тип привязанной доменной сущности. */
+    readonly entityType: TType;
+    /** Привязанная доменная модель. */
+    readonly model: RuntimeEntityModelMap[TType];
+    /** Identity привязанной доменной сущности. */
+    readonly entityIdentity: string;
+    /** Человекочитаемое имя host. */
+    readonly title: string;
+    /** Текущее состояние жизненного цикла host. */
+    status: RuntimeHostStatus;
+    /** Время создания host (timestamp ms). */
+    readonly createdAt: number;
+    /** Время последнего изменения host (timestamp ms). */
+    updatedAt: number;
+    /** Связанные runtime-ресурсы host. */
+    readonly resources: RuntimeHostResource[];
+    /** Связанные каналы взаимодействия host. */
+    readonly channels: RuntimeHostChannel[];
+    /** Произвольные runtime-метаданные host. */
+    readonly meta: Record<string, unknown>;
+    /** Контекст runtime-host (тип зависит от host). */
+    context: TContext;
+    /** Runtime-scoped persistence controller, если host запущен с persistence. */
+    readonly runtimeState: RuntimeStateControllerLike | null;
+    /** Корневая raph-нода host (если есть). */
+    readonly node: RaphNode | null;
+    /** Runtime-scoped базовый путь host в Raph data storage. */
+    readonly basePath: string;
+    /** Возвращает путь runtime state. */
+    statePath: (path?: string) => string;
+    /** Возвращает путь output runtime-host. */
+    outputPath: (name: string) => string;
+    /** Привязывает локальное имя входа к literal либо Raph path. */
+    bindInput: (name: string, binding: RuntimeHostInputBinding) => void;
+    /** Читает разрешённое значение входа. */
+    readInput: (name: string) => unknown;
+    /** Читает все входы одним snapshot. */
+    readInputs: () => Readonly<Record<string, unknown>>;
+    /** Подписывает root runtime-ноду на data path и тип логического обновления. */
+    bindUpdate: (binding: RuntimeHostUpdateBinding) => () => void;
+    /** Возвращает compiled artifact, связанный с host, если он доступен. */
+    getArtifact: () => ProgramArtifact<TArtifactPayload> | null;
+    /** Возвращает session-local reader, через который host читает compiled artifacts. */
+    getArtifactReader: () => RuntimeArtifactReader | null;
+    /** Возвращает payload compiled artifact, связанный с host, если он доступен. */
+    getArtifactPayload: () => TArtifactPayload | null;
+    /** Изменить статус host и обновить updatedAt. */
+    setStatus: (status: RuntimeHostStatus) => void;
+    /** Проверить наличие runtime capability. */
+    hasCapability: (capability: RuntimeHostCapability) => boolean;
+    /** Добавить/обновить runtime-ресурс host. */
+    addResource: (resource: RuntimeHostResource) => void;
+    /** Добавить/обновить канал host. */
+    addChannel: (channel: RuntimeHostChannel) => void;
+    /** Сгенерировать runtime-событие host. */
+    emit: (event: string, payload: any) => void;
+    /** Подписаться на runtime-событие host. */
+    on: (event: string, listener: (payload: any) => void) => any;
+    /** Отписаться от runtime-события host. */
+    off: (event: string, listener: (payload: any) => void) => any;
+    /** Частично обновить context host. */
+    setContext: (patch: Partial<TContext>) => void;
+    /** Полностью заменить context host. */
+    replaceContext: (context: TContext) => void;
+    /** Привязать runtime-scoped persistence controller. */
+    attachRuntimeState: (runtimeState: RuntimeStateControllerLike | null) => void;
+    /** Обработать runtime update, пришедший из логической либо boundary Raph-фазы. */
+    update: (ctx: RuntimeHostUpdateContext) => Promise<void> | void;
+    /** Сериализовать host в снимок для UI/диагностики. */
+    snapshot: () => RuntimeHostSnapshot;
+}

package/dist/features/core/modules/runtime/domain/runtime-project-session.types.d.ts

@@ -0,0 +1,36 @@
+import { RuntimeArtifactReader } from './runtime-host.types';
+import { RuntimeScopeHandle } from './runtime-scope.types';
+import { CompositionPublicOutputHandle, CompositionRuntimeHostHandle, CompositionSession } from '../../source/domain/types/composition-source.types';
+export interface ProjectCompositionRegistry<THost extends CompositionRuntimeHostHandle = CompositionRuntimeHostHandle> {
+    get: (identity: string) => ProjectCompositionHandle<THost> | null;
+    require: (identity: string) => ProjectCompositionHandle<THost>;
+    getAll: () => ProjectCompositionHandle<THost>[];
+}
+export interface ProjectCompositionHandle<THost extends CompositionRuntimeHostHandle = CompositionRuntimeHostHandle> {
+    readonly identity: string;
+    readonly state: 'inactive' | 'active' | 'paused' | 'disposed';
+    readonly host: THost | null;
+    readonly outputs: Readonly<Record<string, CompositionPublicOutputHandle>>;
+    activate: () => Promise<CompositionSession<THost>>;
+    pause: () => Promise<void>;
+    resume: () => Promise<void>;
+    restart: () => Promise<CompositionSession<THost>>;
+    deactivate: () => Promise<void>;
+    output: <T = unknown>(name: string) => T | undefined;
+}
+export interface ProjectRuntimeMountOptions {
+    /** `declared` сохраняет корневой activateOn; `none` создаёт стабильные handles для сессии по требованию или отладки. */
+    autoActivate?: 'declared' | 'none';
+    /** Локальная для сессии проекция артефактов, используемая Preview без изменения Endge.program. */
+    artifactReader?: RuntimeArtifactReader;
+}
+export interface ProjectRuntimeSession<THost extends CompositionRuntimeHostHandle = CompositionRuntimeHostHandle> {
+    readonly id: string;
+    readonly compositions: ProjectCompositionRegistry<THost>;
+    switchScope: (options: {
+        from?: RuntimeScopeHandle | null;
+        to: RuntimeScopeHandle;
+        previous?: 'pause' | 'deactivate';
+    }) => Promise<void>;
+    unmount: () => Promise<void>;
+}

package/dist/features/core/modules/runtime/domain/runtime-registry.types.d.ts

@@ -0,0 +1,40 @@
+import { RuntimeEntityType } from './runtime-entity-map.types';
+import { DestroyedRuntimeHostSnapshot, RuntimeHost, RuntimeHostSnapshot } from './runtime-host.types';
+export interface RuntimeHostRegistrySnapshot {
+    /** Общее количество зарегистрированных host. */
+    total: number;
+    /** Группировка host по статусу. */
+    byStatus: Record<string, number>;
+    /** Снимки всех host на момент запроса. */
+    hosts: RuntimeHostSnapshot[];
+    /** Общее количество удалённых host, сохранённых в debug-архиве. */
+    deletedTotal: number;
+    /** Снимки удалённых host из debug-архива. */
+    deletedHosts: DestroyedRuntimeHostSnapshot[];
+}
+export interface RuntimeHostRegistryLike {
+    /** Зарегистрировать host в registry и вернуть его же. */
+    register: <T extends RuntimeHost<any, any>>(host: T) => T;
+    /** Найти host по runtime-id. */
+    getById: (id: string) => RuntimeHost<any, any> | null;
+    /** Получить список всех host. */
+    getAll: () => RuntimeHost<any, any>[];
+    /** Получить host для конкретной доменной сущности. */
+    getByEntity: (entityType: RuntimeEntityType, entityIdentity: string) => RuntimeHost<any, any>[];
+    /** Удалить host по runtime-id и вернуть удаленный экземпляр. */
+    removeById: (id: string) => RuntimeHost<any, any> | null;
+    /** Очистить registry и разрушить все host. */
+    clear: () => void;
+    /** Сохранить snapshot удалённого host в debug-архив. */
+    rememberDeletedSnapshot: (snapshot: DestroyedRuntimeHostSnapshot) => void;
+    /** Получить снимки удалённых host из debug-архива. */
+    getDeletedSnapshots: () => DestroyedRuntimeHostSnapshot[];
+    /** Удалить один snapshot из debug-архива по runtime-id. */
+    removeDeletedSnapshot: (id: string) => DestroyedRuntimeHostSnapshot | null;
+    /** Немедленно применяет фактическую ограниченную ёмкость инспекции. */
+    setDeletedSnapshotLimit: (limit: number) => void;
+    /** Очистить debug-архив удалённых host. */
+    clearDeleted: () => void;
+    /** Получить сериализованный snapshot registry. */
+    snapshot: () => RuntimeHostRegistrySnapshot;
+}

package/dist/features/core/modules/runtime/domain/runtime-scope.types.d.ts

@@ -0,0 +1,44 @@
+import { RuntimeHost } from './runtime-host.types';
+import { RuntimeResourceBagSnapshot } from './runtime-resource.types';
+export type RuntimeScopeState = 'inactive' | 'activating' | 'active' | 'pausing' | 'paused' | 'resuming' | 'deactivating' | 'error' | 'disposed';
+export interface RuntimeScopeSnapshot {
+    id: string;
+    path: string;
+    parentScopeId: string | null;
+    ownerRuntimeId: string | null;
+    boundaryId: string;
+    state: RuntimeScopeState;
+    generation: number;
+    stale: boolean;
+    updateGateOpen: boolean;
+    childScopeIds: string[];
+    memberRuntimeIds: string[];
+    resources: RuntimeResourceBagSnapshot;
+    lastError: string | null;
+}
+export interface RuntimeScopeHandle {
+    readonly id: string;
+    readonly path: string;
+    readonly state: RuntimeScopeState;
+    readonly boundaryId: string;
+    activate: () => Promise<void>;
+    pause: () => Promise<void>;
+    resume: () => Promise<void>;
+    deactivate: () => Promise<void>;
+    dispose: () => Promise<void>;
+    getRuntime: (path: string) => RuntimeHost<any, any> | null;
+    getOutput: (name: string) => unknown;
+    snapshot: () => RuntimeScopeSnapshot;
+}
+export interface RuntimeScopeLifecycleHooks {
+    activate?: (signal: AbortSignal, generation: number) => Promise<void> | void;
+    pause?: () => Promise<void> | void;
+    resume?: () => Promise<void> | void;
+    reconcile?: () => Promise<void> | void;
+    deactivate?: () => Promise<void> | void;
+    dispose?: () => Promise<void> | void;
+    /** Централизованное завершение сохраняет согласованность RuntimeHostRegistry и индексов scope. */
+    destroyRuntime?: (runtimeId: string) => Promise<void> | void;
+    resolveRuntime?: (path: string) => RuntimeHost<any, any> | null;
+    resolveOutput?: (name: string) => unknown;
+}

package/dist/features/core/modules/runtime/domain/runtime-strategy.types.d.ts

@@ -0,0 +1,36 @@
+import { RuntimeEntityType } from './runtime-entity-map.types';
+import { RuntimeArtifactReader, RuntimeHost } from './runtime-host.types';
+export type RuntimeStrategyMeta = Record<string, any>;
+export type AnyRuntimeHost = RuntimeHost<any, any>;
+/** Контекст создания runtime-host конкретной стратегией. */
+export interface RuntimeCreateContext<TModel = unknown> {
+    /** Уникальный runtime-id, выделенный EndgeRuntime_Module. */
+    id: string;
+    /** Доменная модель, для которой создается runtime-host. */
+    model: TModel;
+    /** Runtime meta/options без служебного parent. */
+    meta: RuntimeStrategyMeta;
+    /** Родительский runtime-host, если запуск вложенный. */
+    parent: AnyRuntimeHost | null;
+    /** Read-only доступ к compiled artifacts текущей Endge.program. */
+    artifacts: RuntimeArtifactReader;
+}
+/** Контекст разрушения runtime-host, если стратегии нужна своя очистка. */
+export interface RuntimeDestroyContext<THost extends AnyRuntimeHost = AnyRuntimeHost> {
+    /** Разрушаемый runtime-host. */
+    host: THost;
+}
+/** Strategy запуска runtime-сущности одного типа. */
+export interface RuntimeStrategy<TModel = unknown, THost extends AnyRuntimeHost = AnyRuntimeHost> {
+    /** Стабильный id стратегии для debug/плагинов. */
+    id: string;
+    /** Канонический runtime entity type, который создает стратегия. */
+    entityType: RuntimeEntityType;
+    /** Проверяет, умеет ли стратегия запустить переданную модель. */
+    supports: (model: unknown) => model is TModel;
+    /** Создает runtime-host. Регистрация в EndgeRuntime_Module здесь не выполняется. */
+    create: (ctx: RuntimeCreateContext<TModel>) => THost | null;
+    /** Выполняет strategy-specific cleanup перед общим host.destroy(). */
+    destroy?: (ctx: RuntimeDestroyContext<THost>) => Promise<void> | void;
+}
+export type AnyRuntimeStrategy = RuntimeStrategy<any, any>;

package/dist/features/core/modules/runtime/domain/runtime.types.d.ts

@@ -0,0 +1,76 @@
+import { RAction } from '../../domain/entities/RAction';
+import { RComponentSFC } from '../../domain/entities/RComponentSFC';
+import { RComposition } from '../../domain/entities/RComposition';
+import { RFilter } from '../../domain/entities/RFilter';
+import { RPage } from '../../domain/entities/RPage';
+import { RProject } from '../../domain/entities/RProject';
+import { RQuery } from '../../domain/entities/RQuery';
+import { RStore } from '../../domain/entities/RStore';
+import { RStream } from '../../domain/entities/RStream';
+import { RuntimeHostRegistrySnapshot } from './runtime-registry.types';
+/**
+ * Виды runtime
+ */
+export type RuntimeKind = 'query' | 'filter' | 'composition' | 'store' | 'stream' | 'action' | 'runtime';
+export type RuntimeExecutableModel = RQuery | RAction | RProject | RPage | RComponentSFC | RFilter | RComposition | RStore | RStream;
+export interface EndgeRuntimeSnapshot extends RuntimeHostRegistrySnapshot {
+    generatedAt: number;
+    scopes: import('./runtime-scope.types').RuntimeScopeSnapshot[];
+}
+/**
+ * Событие для query: изменение фильтра
+ */
+export interface FilterChangeEvent {
+    filterId: string;
+}
+/**
+ * Runtime-события Query
+ */
+export interface QueryRuntimeEvents {
+    'filter:change': FilterChangeEvent;
+}
+export interface ActionRuntimeEvents {
+    'source:change': {
+        events?: unknown[];
+        meta?: Record<string, unknown>;
+    };
+    'step:start': {
+        stepId: string;
+        runtimeId?: string | null;
+        actionId?: string | null;
+        title?: string | null;
+        meta?: Record<string, unknown>;
+    };
+    'step:success': {
+        stepId: string;
+        runtimeId?: string | null;
+        actionId?: string | null;
+        title?: string | null;
+        output?: unknown;
+        meta?: Record<string, unknown>;
+    };
+    'step:error': {
+        stepId: string;
+        runtimeId?: string | null;
+        actionId?: string | null;
+        title?: string | null;
+        error: unknown;
+        meta?: Record<string, unknown>;
+    };
+}
+/**
+ * Типы runtime-профилей
+ */
+export interface RuntimeProfile<K extends RuntimeKind, E extends Record<string, any>> {
+    kind: K;
+    events: E;
+}
+/**
+ * Реестр профилей
+ */
+export interface RuntimeProfiles {
+    query: RuntimeProfile<'query', QueryRuntimeEvents>;
+    action: RuntimeProfile<'action', ActionRuntimeEvents>;
+}
+export type RuntimeProfileByKind<K extends keyof RuntimeProfiles> = RuntimeProfiles[K];
+export type RuntimeEventsByKind<K extends keyof RuntimeProfiles> = RuntimeProfileByKind<K>['events'];

package/dist/features/core/modules/runtime/domain/sfc-render-inspection.type.d.ts

@@ -0,0 +1,48 @@
+import { RComponentSFC_SourceRange } from '../../domain/types/component/sfc/location.types';
+/** Семантический вид узла в живом SFC render tree. */
+export type SFCRenderInspectionNodeKind = 'component' | 'element' | 'text' | 'expression';
+/** Вычисленное значение template binding вместе с его source provenance. */
+export interface SFCRenderInspectionBinding {
+    kind: 'literal' | 'expression';
+    source?: string;
+    reads: string[];
+    value: unknown;
+}
+/** Данные, которыми renderer регистрирует один живой SFC instance. */
+export interface SFCRenderInspectionNodeInput {
+    runtimeId: string;
+    componentIdentity: string;
+    componentStack: string[];
+    scope: string;
+    parentId: string | null;
+    nodeId: string;
+    kind: SFCRenderInspectionNodeKind;
+    tag: string;
+    componentTag?: string;
+    calledComponentIdentity?: string;
+    sourceRange?: RComponentSFC_SourceRange;
+    props: Record<string, unknown>;
+    componentProps: Record<string, unknown>;
+    locals: Record<string, unknown>;
+    bindings: Record<string, SFCRenderInspectionBinding>;
+    meta?: Record<string, unknown>;
+}
+/** Зарегистрированный живой SFC instance. */
+export interface SFCRenderInspectionNode extends SFCRenderInspectionNodeInput {
+    id: string;
+    updatedAt: number;
+}
+/** Иерархическая проекция зарегистрированных SFC instances. */
+export interface SFCRenderInspectionTreeNode extends SFCRenderInspectionNode {
+    children: SFCRenderInspectionTreeNode[];
+}
+/** Optional renderer-neutral sink: при null runtime не выполняет inspection work. */
+export interface SFCRenderInspectionSessionLike {
+    registerNode: (input: SFCRenderInspectionNodeInput) => string;
+    unregisterNode: (id: string) => void;
+    getNode: (id: string) => SFCRenderInspectionNode | null;
+    getTree: (runtimeId?: string) => SFCRenderInspectionTreeNode[];
+    subscribe: (listener: () => void) => VoidFunction;
+    clearRuntime: (runtimeId: string) => void;
+    clear: () => void;
+}