@endge/core 1.2.5 → 1.2.7

package/dist/model/endge/program/endge-program.d.ts

@@ -0,0 +1,105 @@
+import { ActionCompiledFlow } from '../../../domain/types/flow/action.types';
+import { FilterProgramPayload } from '../../../domain/types/source/filter-source.types';
+import { CompositionProgramPayload } from '../../../domain/types/source/composition-source.types';
+import { StoreSourceArtifact } from '../../../domain/types/source/store-source.types';
+import { TypeProgramCatalogEntry, TypeProgramPayload } from '../../../domain/types/source/type-source.types';
+import { EndgeModule } from '../../../domain/entities/endge/EndgeModule';
+import { DataViewProgramPayload, EndgeProgramSnapshot, ProgramArtifact, ProgramArtifactRef, ProgramArtifactStatus, ComponentSFCTagRegistryEntry, ComputationProgramPayload, ProgramDiagnostic, ProgramEntityType, QueryProgramPayload, EndgeStyleProgramPayload } from '../../../domain/types/program/program.types';
+/**
+ * Хранилище compiled artifacts, полученных после компиляции домена.
+ */
+export declare class EndgeProgram extends EndgeModule {
+    private _artifacts;
+    private _indexByIdentity;
+    private _componentIdentityByTag;
+    private _status;
+    private _compilerVersion;
+    /**
+     * Возвращает общий статус текущей compiled program.
+     */
+    get status(): ProgramArtifactStatus;
+    /**
+     * Возвращает версию компилятора, которой собрана текущая program.
+     */
+    get compilerVersion(): string;
+    /**
+     * Открывает новую сессию компиляции и очищает предыдущие artifacts.
+     */
+    beginCompile(compilerVersion: string): void;
+    /**
+     * Обновляет общий статус program с учетом приоритета warning/error.
+     */
+    setStatus(status: ProgramArtifactStatus): void;
+    /** Пересчитывает общий status после compiler linking pass. */
+    recalculateStatus(): void;
+    /**
+     * Добавляет compiled artifact и индексирует его по id и identity.
+     */
+    addArtifact<TPayload>(artifact: ProgramArtifact<TPayload>): ProgramArtifact<TPayload>;
+    /** Заменяет build-derived registry пользовательских SFC tags. */
+    setComponentTags(entries: readonly ComponentSFCTagRegistryEntry[]): void;
+    /** Разрешает пользовательский SFC tag в persisted identity компонента. */
+    resolveComponentTag(tag: string): string | null;
+    /** Возвращает snapshot build-derived registry без выдачи mutable Map наружу. */
+    getComponentTags(): ComponentSFCTagRegistryEntry[];
+    /**
+     * Возвращает artifact по типу сущности и id или identity.
+     */
+    getArtifact<TPayload = unknown>(entityType: ProgramEntityType, idOrIdentity: string | number): ProgramArtifact<TPayload> | null;
+    /**
+     * Возвращает artifact по compact reference.
+     */
+    getArtifactByRef<TPayload = unknown>(ref: Pick<ProgramArtifactRef, 'entityType'> & {
+        id?: string | number;
+        identity?: string;
+    }): ProgramArtifact<TPayload> | null;
+    /**
+     * Возвращает compiled flow для action.
+     */
+    getActionFlow(idOrIdentity: string | number): ActionCompiledFlow | null;
+    /** Возвращает compiled query artifact по id или identity. */
+    getQueryArtifact(idOrIdentity: string | number): ProgramArtifact<QueryProgramPayload> | null;
+    /** Returns a compiled Computation artifact by id or identity. */
+    getComputationArtifact(idOrIdentity: string | number): ProgramArtifact<ComputationProgramPayload> | null;
+    /** Возвращает compiled DataView artifact по id или identity. */
+    getDataViewArtifact(idOrIdentity: string | number): ProgramArtifact<DataViewProgramPayload> | null;
+    /** Возвращает compiled Store artifact по id или identity. */
+    getStoreArtifact(idOrIdentity: string | number): ProgramArtifact<StoreSourceArtifact> | null;
+    /** Возвращает compiled Filter artifact по id или identity. */
+    getFilterArtifact(idOrIdentity: string | number): ProgramArtifact<FilterProgramPayload> | null;
+    /** Возвращает compiled Composition artifact по id или identity. */
+    getCompositionArtifact(idOrIdentity: string | number): ProgramArtifact<CompositionProgramPayload> | null;
+    /** Returns a compiled EndgeCSS document by persisted id or identity. */
+    getStyleArtifact(idOrIdentity: string | number): ProgramArtifact<EndgeStyleProgramPayload> | null;
+    /** Returns one compiler-owned Type artifact. */
+    getTypeArtifact(idOrIdentity: string | number): ProgramArtifact<TypeProgramPayload> | null;
+    /** Stable editor-facing catalog derived only from compiled Type artifacts. */
+    getTypeCatalog(): TypeProgramCatalogEntry[];
+    /**
+     * Возвращает diagnostics для конкретного artifact или всей program.
+     */
+    getDiagnostics(ref?: Pick<ProgramArtifactRef, 'entityType'> & {
+        id?: string | number;
+        identity?: string;
+    }): ProgramDiagnostic[];
+    /**
+     * Возвращает все compiled artifacts.
+     */
+    getArtifacts(): ProgramArtifact[];
+    /**
+     * Очищает compiled program и возвращает статус в `valid`.
+     */
+    clear(): void;
+    /**
+     * Сбрасывает program при reset federation.
+     */
+    reset(): void;
+    /**
+     * Формирует summary snapshot для диагностики compiled program.
+     */
+    snapshot(): EndgeProgramSnapshot;
+    /**
+     * Внутренний helper модуля: key For.
+     */
+    private keyFor;
+}

package/dist/model/endge/program/endge-source.d.ts

@@ -0,0 +1,56 @@
+import { SourceEngineCompileResult, SourceEngineGenerateResult, SourceEngineStrategy, SourceLanguageCompletion, SourceLanguageContext, SourceLanguageSemanticHighlight, SourceDocumentReference, SourceLanguageStrategy, SourceLanguageValidationResult, SourceKind, SourceParseResult, SourcePatchResult, SourcePatchStrategy } from '../../../domain/types/source/source-engine.types';
+import { EndgeModule } from '../../../domain/entities/endge/EndgeModule';
+/** Модуль authoring-операций над source-документами Endge. */
+export declare class EndgeSource extends EndgeModule {
+    private readonly _strategies;
+    private readonly _languageStrategies;
+    private readonly _patchStrategies;
+    /** Создаёт source-модуль и регистрирует встроенные strategies. */
+    constructor();
+    /** Регистрирует source strategy. Повторная регистрация с тем же id заменяет старую. */
+    registerStrategy(strategy: SourceEngineStrategy): void;
+    /** Регистрирует source language strategy. Повторная регистрация с тем же id заменяет старую. */
+    registerLanguageStrategy(strategy: SourceLanguageStrategy): void;
+    /** Регистрирует source patch strategy. Повторная регистрация с тем же id заменяет старую. */
+    registerPatchStrategy(strategy: SourcePatchStrategy): void;
+    /** Возвращает копию списка зарегистрированных source strategies. */
+    listStrategies(): SourceEngineStrategy[];
+    /** Возвращает копию списка зарегистрированных source language strategies. */
+    listLanguageStrategies(): SourceLanguageStrategy[];
+    /** Возвращает копию списка зарегистрированных source patch strategies. */
+    listPatchStrategies(): SourcePatchStrategy[];
+    /** Возвращает стратегию для указанного source-kind. */
+    resolveStrategy(sourceKind: SourceKind | string): SourceEngineStrategy | null;
+    /** Возвращает language strategy для указанного source-kind. */
+    resolveLanguageStrategy(sourceKind: SourceKind | string): SourceLanguageStrategy | null;
+    /** Возвращает patch strategy для указанного source-kind. */
+    resolvePatchStrategy(sourceKind: SourceKind | string): SourcePatchStrategy | null;
+    /** Генерирует source для указанного source-kind через зарегистрированную strategy. */
+    generate(sourceKind: SourceKind | string, model: unknown): SourceEngineGenerateResult;
+    /** Компилирует source указанного source-kind в normalized document и artifact payload. */
+    compile(sourceKind: SourceKind | string, source: string): SourceEngineCompileResult;
+    /** Парсит source указанного source-kind в normalized editor document. */
+    parse<TDocument = unknown>(sourceKind: SourceKind | string, source: string): SourceParseResult<TDocument>;
+    /** Патчит source указанного source-kind, сохраняя нетронутые участки авторского кода. */
+    patch<TPatch = unknown, TDocument = unknown>(sourceKind: SourceKind | string, source: string, patch: TPatch): SourcePatchResult<TDocument>;
+    /** Возвращает базовый source для новой сущности указанного source-kind. */
+    createDefault(sourceKind: SourceKind | string): string;
+    /** Нормализует source через language strategy без изменения semantic document. */
+    normalize(sourceKind: SourceKind | string, source: string): string;
+    /** Валидирует source указанного source-kind для editor-facing сценариев. */
+    validate(sourceKind: SourceKind | string, source: string, context?: Omit<SourceLanguageContext, 'source'>): SourceLanguageValidationResult;
+    /** Возвращает editor-facing completion items для указанного source-kind. */
+    completions(sourceKind: SourceKind | string, context: SourceLanguageContext): SourceLanguageCompletion[];
+    /** Возвращает семантическую ссылку на внешний документ под курсором. */
+    referenceAt(sourceKind: SourceKind | string, context: SourceLanguageContext): SourceDocumentReference | null;
+    /** Возвращает renderer-neutral semantic highlights для source-документа. */
+    semanticHighlights(sourceKind: SourceKind | string, context: SourceLanguageContext): SourceLanguageSemanticHighlight[];
+    /** Регистрирует встроенные strategies ядра. */
+    private _registerDefaultStrategies;
+    /** Возвращает strategy или бросает явную ошибку для некорректного source-kind. */
+    private _resolveRequiredStrategy;
+    /** Возвращает language strategy или бросает явную ошибку для некорректного source-kind. */
+    private _resolveRequiredLanguageStrategy;
+    /** Возвращает patch strategy или бросает явную ошибку для некорректного source-kind. */
+    private _resolveRequiredPatchStrategy;
+}

package/dist/model/endge/program/index.d.ts

@@ -0,0 +1,3 @@
+export * from './endge-source';
+export * from './endge-program';
+export * from './endge-compiler';

package/dist/model/endge/runtime/core/endge-actions.d.ts

@@ -0,0 +1,72 @@
+import { RAction } from '../../../../domain/entities/reflect/RAction';
+import { ActionDefinitionInput, ActionExecuteOptions, ImplementationBindingScope, ResolvedActionDescriptor, RuntimeAction, RuntimeActionContext, RuntimeActionId, RuntimeActionRegistrySnapshot } from '../../../../domain/types/runtime/action.types';
+import { ImplementationProvider } from '../../../../domain/types/runtime/implementation.types';
+import { Subscribable } from '@endge/utils';
+import { EndgeImplementations } from '../implementation/endge-implementations';
+export interface CodeActionDefinition extends Omit<ActionDefinitionInput, 'owner'> {
+    owner: string;
+    catalogPath?: readonly string[];
+    providerKey?: string;
+    execute?: ImplementationProvider['execute'];
+    canExecute?: ImplementationProvider['canExecute'];
+}
+export interface ActionOverrideInput {
+    owner: string;
+    providerKey?: string;
+    execute?: ImplementationProvider['execute'];
+    canExecute?: ImplementationProvider['canExecute'];
+    scope?: Exclude<ImplementationBindingScope, 'default' | 'invocation'>;
+    scopeIdentity?: string;
+    priority?: number;
+}
+/** Action-specific facade over semantic definitions and generic implementations. */
+export declare class EndgeActions extends Subscribable {
+    private readonly _implementations;
+    private readonly _codeActions;
+    private readonly _catalogPaths;
+    private readonly _codeActionDisposers;
+    private readonly _providerDisposers;
+    private _hasSynchronizedResolvedIndex;
+    constructor(_implementations: EndgeImplementations);
+    /** Rebuilds code-owned defaults. Local application code registers again after reset. */
+    reset(): void;
+    /** Defines a core/plugin Action that has no Payload record. */
+    defineBuiltin(definition: CodeActionDefinition): () => void;
+    /** Defines a session-local Action. Identity collisions must use explicit override(). */
+    defineLocal(definition: CodeActionDefinition): () => void;
+    /** Binds local code over an existing Action without mutating its definition. */
+    override(identity: string, override: ActionOverrideInput): () => void;
+    /** Executes a resolved Action through the generic implementation pipeline. */
+    execute<TResult = unknown>(identity: RuntimeActionId, optionsOrContext?: ActionExecuteOptions | RuntimeActionContext, legacyPayload?: unknown): Promise<TResult | undefined>;
+    /** Returns effective definitions for palettes and the Domain Widget. */
+    listResolved(): ResolvedActionDescriptor[];
+    /** Compatibility projection for existing context-menu code. */
+    list(input?: {
+        surface?: string;
+    }): RuntimeAction[];
+    get(id: RuntimeActionId): RuntimeAction | null;
+    has(id: RuntimeActionId): boolean;
+    /** Compiler inspection API for code-owned identity collision diagnostics. */
+    getCodeDefinition(identity: string): RAction | null;
+    /** Returns the semantic definition regardless of storage origin. */
+    getDefinition(identity: string): RAction | null;
+    canExecute(id: RuntimeActionId, context: RuntimeActionContext, payload?: unknown): boolean;
+    /** @deprecated Use defineLocal(), defineBuiltin() or override(). */
+    register(action: RuntimeAction): () => void;
+    unregister(id: RuntimeActionId): void;
+    serialize(): RuntimeActionRegistrySnapshot;
+    private _defineCodeAction;
+    private _findAction;
+    private _defaultProviderKey;
+    private _contractOf;
+    private _describe;
+    private _registerCoreProviders;
+    private _registerTableActions;
+    /** Bridges typed Action invocation to the legacy context-menu adapter during migration. */
+    private _tableInvocationContext;
+    private _registerCoreActions;
+    private _syncResolvedIndex;
+    private _legacyAction;
+    private _isLegacyContext;
+    private _legacyTarget;
+}

package/dist/model/endge/{endge-bind.d.ts → runtime/core/endge-bind.d.ts}

@@ -1,12 +1,25 @@
-import { ActionStepHandler } from '../../domain/types/action.types';
-import { EndgeModule } from '../../domain/entities/endge/EndgeModule';
-import { RAction } from '../../domain/entities/reflect/RAction';
-import { RQuery } from '../../domain/entities/reflect/RQuery';
+import { ActionStepHandler } from '../../../../domain/types/flow/action.types';
+import { ComputationOverride } from '../../../../domain/types/computation';
+import { EndgeModule } from '../../../../domain/entities/endge/EndgeModule';
+import { RAction } from '../../../../domain/entities/reflect/RAction';
 /**
  * Привязка кастомного кода к существующим сущностям ядра.
  * Не связана с declarative bindings и event contracts.
  */
 export declare class EndgeBind extends EndgeModule {
+    private readonly computationOverrides;
+    /**
+     * Регистрирует built-in converters и runtime action handlers после загрузки домена.
+     */
+    start(): void;
+    /**
+     * Регистрирует Default Converters.
+     */
+    private registerDefaultConverters;
+    /**
+     * Регистрирует Default Actions.
+     */
+    private registerDefaultActions;
     /**
      * Находит конвертер по identity и ставит кастомный обработчик (setCustom).
      * @param identity - id конвертера в домене
@@ -16,17 +29,15 @@ export declare class EndgeBind extends EndgeModule {
     converter(identity: string, handler: (v: any) => any): boolean;
     /**
      * Привязывает обработчик runtime-step в контексте конкретного action.
+     * @deprecated Для полного Action используйте Endge.actions.override(); этот API оставлен только для legacy runtimeAction nodes.
      * @param actionOrId - действие или его id/identity
      * @param runtimeId - id runtime-step внутри переданного action
      * @param handler - обработчик шага
      * @returns true, если action и runtime-step найдены, и обработчик установлен
      */
     action(actionOrId: RAction | string | number, runtimeId: string, handler: ActionStepHandler): boolean;
-    /**
-     * Подвязывает кастомный executor и/или generator к запросу из домена.
-     * @param identityOrId - RQuery или id/identity запроса
-     * @param executor - функция выполнения запроса
-     * @returns true, если запрос найден и override применён
-     */
-    query(identityOrId: RQuery | string | number, executor: () => Promise<any>): boolean;
+    /** Registers a local full replacement for a persisted computation graph. */
+    computation(identity: string, override: ComputationOverride): VoidFunction;
+    /** Runtime-only lookup used by EndgeComputation. */
+    getComputation(identity: string): ComputationOverride | null;
 }

package/dist/model/endge/runtime/core/endge-runtime.d.ts

@@ -0,0 +1,143 @@
+import { RuntimeEntityType } from '../../../../domain/types/runtime/runtime-entity-map.types';
+import { AnyRuntimeStrategy, AnyRuntimeHost } from '../../../../domain/types/runtime/runtime-strategy.types';
+import { RuntimeExecuteOptions } from '../../../../domain/types/runtime/runtime-execute.type';
+import { EndgeRuntimeSnapshot, RuntimeExecutableModel } from '../../../../domain/types/runtime/runtime.types';
+import { EndgeModule } from '../../../../domain/entities/endge/EndgeModule';
+import { RuntimeAppScope, RuntimeAppScopeOptions } from '../../../../domain/entities/runtime/RuntimeAppScope';
+import { RuntimeScope } from '../../../../domain/entities/runtime/RuntimeScope';
+import { RuntimeScopeRegistry } from '../../../../domain/entities/runtime/RuntimeScopeRegistry';
+import { EndgeActions } from './endge-actions';
+import { EndgeImplementations } from '../implementation/endge-implementations';
+import { EndgeComposition } from '../execution/endge-composition';
+import { EndgeProject } from '../execution/endge-project';
+import { EndgeDataView } from '../execution/endge-data-view';
+import { EndgeQuery } from '../execution/endge-query';
+import { EndgeComputation } from '../execution/endge-computation';
+import { EndgeFlow } from '../flow/endge-flow';
+import { EndgeFlowRegistry } from '../flow/endge-flow-registry';
+/** Модуль создания, регистрации и уничтожения runtime hosts и app scopes. */
+export declare class EndgeRuntime extends EndgeModule {
+    readonly computation: EndgeComputation;
+    readonly query: EndgeQuery;
+    readonly dataView: EndgeDataView;
+    readonly composition: EndgeComposition;
+    readonly project: EndgeProject;
+    readonly flowRegistry: EndgeFlowRegistry;
+    readonly flow: EndgeFlow;
+    readonly implementations: EndgeImplementations;
+    readonly actions: EndgeActions;
+    readonly scopes: RuntimeScopeRegistry;
+    private _hosts;
+    private _strategies;
+    private _inited;
+    private _appNode;
+    private _scopeNodes;
+    private _appScopes;
+    private _defaultAppScope;
+    private _unsubscribeWorkspace;
+    private _retainDestroyedHostSnapshots;
+    /** Показывает, сохраняются ли snapshots уничтоженных hosts для runtime inspection. */
+    get retainDestroyedHostSnapshots(): boolean;
+    /** Включает или отключает сохранение snapshots уничтоженных runtime hosts. */
+    set retainDestroyedHostSnapshots(value: boolean);
+    /** Создаёт default app scope и регистрирует runtime strategies. */
+    constructor();
+    /**
+     * Настраивает Raph runtime до загрузки и сборки домена.
+     */
+    setup(): void;
+    /**
+     * Регистрирует runtime-фазы в Raph один раз.
+     */
+    start(): void;
+    /**
+     * Создаёт runtime-host для переданной доменной модели.
+     */
+    execute(model: RuntimeExecutableModel, options?: RuntimeExecuteOptions): AnyRuntimeHost | null;
+    /**
+     * Регистрирует стратегию запуска runtime-сущности.
+     */
+    registerStrategy(strategy: AnyRuntimeStrategy): void;
+    /** Создаёт или возвращает именованный root runtime scope приложения. */
+    createAppScope(options: RuntimeAppScopeOptions): RuntimeAppScope;
+    /** Возвращает lifecycle scope, которому принадлежит RuntimeHost. */
+    getRuntimeScopeByHost(runtimeId: string): RuntimeScope | null;
+    /** Возвращает корневой scope обычного запуска приложения. */
+    getDefaultAppScope(): RuntimeAppScope;
+    /** Возвращает зарегистрированный AppScope. */
+    getAppScope(id: string): RuntimeAppScope | null;
+    /**
+     * Возвращает runtime-host по его runtime-id.
+     */
+    getRuntimeById<T = AnyRuntimeHost>(runtimeId: string): T | null;
+    /**
+     * Возвращает список всех активных runtime-host.
+     */
+    getRuntimeHosts(): AnyRuntimeHost[];
+    /**
+     * Инвалидирует все renderable roots активных application scopes.
+     * Операция намеренно coarse-grained: locale меняется редко, поэтому отдельный
+     * dependency graph переводов на этом этапе не нужен.
+     */
+    invalidateApplicationScopes(): void;
+    /** Регистрирует host, созданный владельцем составной runtime-сущности. */
+    registerRuntimeHost(host: AnyRuntimeHost): boolean;
+    /**
+     * Возвращает snapshots удалённых runtime hosts для inspection tools.
+     */
+    getDeletedRuntimeHostSnapshots(): import('../../../../domain/types/runtime/runtime-host.types').RuntimeHostSnapshot[];
+    /**
+     * Полностью удаляет один snapshot уничтоженного runtime host.
+     */
+    removeDeletedRuntimeHostSnapshot(runtimeId: string): void;
+    /**
+     * Полностью очищает snapshots уничтоженных runtime hosts.
+     */
+    clearDeletedRuntimeHostSnapshots(): void;
+    /**
+     * Возвращает runtime-host по доменной сущности.
+     */
+    getRuntimeHostsByEntity(entityType: RuntimeEntityType, entityIdentity: string, appScopeId?: string): AnyRuntimeHost[];
+    /**
+     * Возвращает общий snapshot runtime-состояния.
+     */
+    snapshot(): EndgeRuntimeSnapshot;
+    /**
+     * Корректно разрушает runtime-host по runtime-id.
+     */
+    destroyRuntime(runtimeId: string): void;
+    /**
+     * Корректно разрушает runtime-host и всех его дочерних host.
+     */
+    destroyRuntimeTree(runtimeId: string): void;
+    /** Корректно разрушает runtime tree и ждёт завершения всего teardown. */
+    destroyRuntimeTreeAsync(runtimeId: string): Promise<void>;
+    /**
+     * Корректно разрушает все зарегистрированные runtime-host.
+     */
+    reset(): Promise<void>;
+    /** Projects effective workspace variables into the runtime Raph namespace. */
+    private syncWorkspaceVariablesToRaph;
+    /** Restores persisted runtime filter values independently of workspace variables. */
+    private hydrateRuntimeFilters;
+    /**
+     * Внутренний destroy для host с контролем уведомления подписчиков.
+     */
+    private destroyRuntimeInternal;
+    /** Регистрирует host, подключает infrastructure и только затем активирует его. */
+    private registerAndActivateHost;
+    /** Creates the lifecycle root lazily again after a full Endge.reset(). */
+    private ensureLifecycleAppScope;
+    /**
+     * Регистрирует встроенные стратегии в порядке от специальных к общим.
+     */
+    private registerDefaultStrategies;
+    /** Разрешает scope запуска: explicit -> parent -> default app. */
+    private resolveAppScope;
+    /** Создаёт Raph graph node для AppScope независимо от data namespace. */
+    private ensureScopeNode;
+    /** Разрешает и проверяет явно переданный parent host. */
+    private resolveParentHost;
+    /** Разрешает artifact reader и запрещает невалидную явную зависимость. */
+    private _resolveArtifactReader;
+}

package/dist/model/endge/runtime/core/endge-updates.d.ts

@@ -0,0 +1,12 @@
+import { EndgeModule } from '../../../../domain/entities/endge/EndgeModule';
+/**
+ * Модуль применения внешних update-сообщений к runtime state.
+ * Устаревшие update-профили из документа настроек удалены; новый SSE pipeline
+ * должен описываться отдельной доменной моделью.
+ */
+export declare class EndgeUpdates extends EndgeModule {
+    /** Обрабатывает legacy update profile; текущая реализация оставлена как no-op boundary. */
+    applyUpdateForProfile(profileIdentity: string, message: unknown, opts?: {
+        vars?: Record<string, string>;
+    }): number;
+}

package/dist/model/endge/runtime/core/index.d.ts

@@ -0,0 +1,4 @@
+export * from './endge-runtime';
+export * from './endge-bind';
+export * from './endge-actions';
+export * from './endge-updates';

package/dist/model/endge/runtime/execution/computation/ComputationGraphExecutor.d.ts

@@ -0,0 +1,27 @@
+import { ComputationDependencyRunner, ComputationExecutionScope, ComputationProgramPayload, ComputationSandboxAdapter } from '../../../../../domain/types/computation';
+export declare class ComputationRuntimeError extends Error {
+    readonly computationIdentity: string;
+    readonly kind: string;
+    readonly outputName?: string | undefined;
+    readonly name = "ComputationRuntimeError";
+    constructor(message: string, computationIdentity: string, kind: string, outputName?: string | undefined, options?: ErrorOptions);
+    toJSON(): {
+        readonly name: "ComputationRuntimeError";
+        readonly message: string;
+        readonly computationIdentity: string;
+        readonly outputName: string | undefined;
+        readonly kind: string;
+    };
+}
+/** Executes compiler-ordered computation graphs without evaluating authored JS in core. */
+export declare class ComputationGraphExecutor {
+    private readonly sandbox;
+    private readonly dependencies;
+    constructor(sandbox: () => ComputationSandboxAdapter | null, dependencies?: ComputationDependencyRunner | null);
+    runSync(payload: ComputationProgramPayload, input: unknown, identity: string, scope?: ComputationExecutionScope): unknown;
+    run(payload: ComputationProgramPayload, input: unknown, identity: string, scope?: ComputationExecutionScope): Promise<unknown>;
+    private executeNode;
+    private evaluate;
+    private evaluateResult;
+    private evaluateNode;
+}

package/dist/model/endge/runtime/execution/computation/ComputationResource.d.ts

@@ -0,0 +1,27 @@
+import { ComputationResource as ComputationResourceContract, ComputationRuntimeErrorShape } from '../../../../../domain/types/computation';
+type AsyncRunner<T> = (input: unknown) => Promise<T>;
+type SyncRunner<T> = (input: unknown) => T;
+/** Renderer-neutral latest-wins state for one computation consumer. */
+export declare class ComputationResourceState<T = unknown> implements ComputationResourceContract<T> {
+    private readonly asyncRunner;
+    private readonly syncRunner;
+    private _status;
+    private _value;
+    private _error;
+    private _listeners;
+    private _revision;
+    private _disposed;
+    private _input;
+    constructor(input: unknown, asyncRunner: AsyncRunner<T>, syncRunner?: SyncRunner<T> | null);
+    get status(): import('../../../../../domain/types/computation').ComputationResourceStatus;
+    get loading(): boolean;
+    get value(): T | undefined;
+    get error(): ComputationRuntimeErrorShape | null;
+    updateInput(input: unknown): void;
+    refresh(): Promise<void>;
+    subscribe(listener: VoidFunction): VoidFunction;
+    dispose(): void;
+    private runSync;
+    private notify;
+}
+export {};

package/dist/model/endge/runtime/execution/computation/ComputationResourceRegistry.d.ts

@@ -0,0 +1,9 @@
+import { ComputationResource as ComputationResourceContract } from '../../../../../domain/types/computation';
+import { ComputationResourceState } from './ComputationResource';
+/** Host-owned registry that isolates resources by call site and row consumer key. */
+export declare class ComputationResourceRegistry {
+    private readonly resources;
+    private readonly disposers;
+    getOrCreate(key: string, input: unknown, create: () => ComputationResourceState, onChange?: VoidFunction): ComputationResourceContract;
+    dispose(): void;
+}

package/dist/model/endge/runtime/execution/computation/EndgeComputation.d.ts

@@ -0,0 +1,25 @@
+import { ComputationProgramPayload, ComputationSandboxAdapter, ComputationSandboxRequest } from '../../../../../domain/types/computation';
+import { ProgramArtifact } from '../../../../../domain/types/program/program.types';
+import { ComputationResourceState } from './ComputationResource';
+/** Executes compiled computation graphs and creates renderer-neutral resources. */
+export declare class EndgeComputation {
+    private sandbox;
+    private readonly executor;
+    private readonly api;
+    setSandboxAdapter(adapter: ComputationSandboxAdapter | null): void;
+    /** Executes an already compiler-validated function in the shared isolated sandbox. */
+    executeSandbox(request: ComputationSandboxRequest): Promise<unknown>;
+    run(idOrIdentity: string | number, input: unknown): Promise<unknown>;
+    runArtifact(artifact: ProgramArtifact<ComputationProgramPayload>, input: unknown): Promise<unknown>;
+    runSync(idOrIdentity: string | number, input: unknown): unknown;
+    runArtifactSync(artifact: ProgramArtifact<ComputationProgramPayload>, input: unknown): unknown;
+    private _run;
+    private _runSync;
+    createResource(identity: string, input: unknown, _consumerKey: string): ComputationResourceState;
+    private requireArtifact;
+    private assertArtifact;
+    /** Создает child scope и блокирует runtime recursion или чрезмерно глубокий call graph. */
+    private _enterExecution;
+    private runOverrideSync;
+    private runOverride;
+}

package/dist/model/endge/runtime/execution/endge-composition.d.ts

@@ -0,0 +1,8 @@
+import { CompositionMountOptions, CompositionPreviewProps, CompositionSession } from '../../../../domain/types/source/composition-source.types';
+/** Публичный facade монтирования Composition runtime sessions. */
+export declare class EndgeComposition {
+    /** Монтирует Composition runtime и возвращает управляемую session. */
+    mount(identity: string, options?: CompositionMountOptions): Promise<CompositionSession>;
+}
+/** Materializes preview-only literals and RMock references into regular Composition props. */
+export declare function materializeCompositionPreviewProps(previewProps: CompositionPreviewProps | null | undefined): Record<string, unknown>;

package/dist/model/endge/runtime/execution/endge-computation.d.ts

@@ -0,0 +1,4 @@
+export * from './computation/EndgeComputation';
+export * from './computation/ComputationGraphExecutor';
+export * from './computation/ComputationResource';
+export * from './computation/ComputationResourceRegistry';

package/dist/model/endge/runtime/execution/endge-data-view.d.ts

@@ -0,0 +1,50 @@
+import { DataViewRef, DataViewRunTools } from '../../../../domain/types/source/data-view-source.types';
+import { DataViewProgramPayload, ProgramArtifact } from '../../../../domain/types/program/program.types';
+import { RDataView } from '../../../../domain/entities/reflect/RDataView';
+/** Модуль выполнения скомпилированных RDataView artifacts. */
+export declare class EndgeDataView {
+    /** Выполняет DataView по id/identity/model над переданным input object. */
+    run(dataViewOrId: RDataView | string | number, input: unknown, tools?: Partial<DataViewRunTools>): unknown;
+    /** Выполняет уже скомпилированный DataView artifact без поиска в домене. */
+    runArtifact(artifact: ProgramArtifact<DataViewProgramPayload>, input: unknown, tools?: Partial<DataViewRunTools>): unknown;
+    /** Выполняет уже скомпилированный DataView payload. */
+    runPayload(artifact: DataViewProgramPayload, input: unknown, tools?: Partial<DataViewRunTools>, context?: {
+        children?: ProgramArtifact[];
+    }): unknown;
+    /** Вычисляет object projection один раз над целым DataView input. */
+    private _runProjection;
+    /** Вычисляет root ValueExpression без object projection wrapper. */
+    private _runExpression;
+    /** Выполняет DataView-ссылку из query/DataView artifact. */
+    runRef(ref: DataViewRef, input: unknown, tools?: Partial<DataViewRunTools>, context?: {
+        children?: ProgramArtifact[];
+    }): unknown;
+    /** Выполняет DataView source без записи artifact в `Endge.program`. */
+    runSource(source: string, input: unknown, tools?: Partial<DataViewRunTools>): unknown;
+    /** Возвращает DataView model из домена или входного экземпляра. */
+    private _resolveDataView;
+    /** Возвращает compiled artifact, компилируя DataView локально при необходимости. */
+    private _resolveArtifact;
+    /** Выполняет manual transform в controlled wrapper текущего frontend runtime. */
+    private _runManual;
+    /** Интерпретирует декларативные pipeline steps без eval. */
+    private _runPipeline;
+    /** Последовательно вычисляет whole-value steps; каждый select получает результат предыдущего. */
+    private _runSelectPipeline;
+    /** Собирает базовый output для map step из spread-источников. */
+    private _createMapOutput;
+    /** Вычисляет join-result для текущей строки pipeline. */
+    private _resolveJoin;
+    /** Вычисляет одно поле map-expression. */
+    private _evaluateExpression;
+    /** Применяет chain operation к path-expression. */
+    private _applyPathOperation;
+    /** Создает набор runtime tools с возможностью точечной подмены в preview. */
+    private _createTools;
+    /** Минимальные built-in converters для preview v1. */
+    private _convert;
+    /** Читает dot-path из object/array без выбрасывания ошибок. */
+    private _path;
+    /** Ищет локальный DataView artifact среди child artifacts, включая вложенные children. */
+    private _findLocalDataViewArtifact;
+}

package/dist/model/endge/runtime/execution/endge-project.d.ts

@@ -0,0 +1,5 @@
+import { ProjectRuntimeMountOptions, ProjectRuntimeSession } from '../../../../domain/types/runtime/runtime-project-session.types';
+/** Mounts one project into an isolated runtime session. */
+export declare class EndgeProject {
+    mount(identity: string, options?: ProjectRuntimeMountOptions): Promise<ProjectRuntimeSession>;
+}