@endge/core 1.2.5 → 1.2.7

package/dist/domain/entities/runtime/RuntimeHostRegistry.d.ts

@@ -1,9 +1,10 @@
-import { RuntimeEntityType } from '../../types/runtime-entity-map.types';
-import { RuntimeHost, RuntimeHostSnapshot } from '../../types/runtime-host.types';
-import { RuntimeHostRegistryLike, RuntimeHostRegistrySnapshot } from '../../types/runtime-registry.types';
+import { RuntimeEntityType } from '../../types/runtime/runtime-entity-map.types';
+import { RuntimeHost, RuntimeHostSnapshot } from '../../types/runtime/runtime-host.types';
+import { RuntimeHostRegistryLike, RuntimeHostRegistrySnapshot } from '../../types/runtime/runtime-registry.types';
 export declare class RuntimeHostRegistry implements RuntimeHostRegistryLike {
     private _hosts;
     private _indexByEntity;
+    private _childrenByParent;
     private _deletedSnapshots;
     /**
      * ACCESS
@@ -17,6 +18,8 @@ export declare class RuntimeHostRegistry implements RuntimeHostRegistryLike {
      * ACCESS
      */
     getAll(): RuntimeHost<any, any>[];
+    /** Возвращает runtime subtree в безопасном для destroy порядке: children first. */
+    getTreePostOrder(rootId: string): string[];
     /**
      * ACCESS
      */

package/dist/domain/entities/runtime/RuntimeResourceBag.d.ts

@@ -0,0 +1,12 @@
+import { RuntimeOwnedResource, RuntimeResourceBagSnapshot } from '../../types/runtime/runtime-resource.types';
+/** Владеет disposable runtime resources и освобождает их в обратном порядке. */
+export declare class RuntimeResourceBag {
+    private readonly _resources;
+    private _paused;
+    add<T extends RuntimeOwnedResource>(resource: T): T;
+    has(id: string): boolean;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    dispose(): Promise<void>;
+    snapshot(): RuntimeResourceBagSnapshot;
+}

package/dist/domain/entities/runtime/RuntimeScope.d.ts

@@ -1,45 +1,56 @@
-import { EventBus } from '@endge/utils';
-export declare enum RuntimeEventType {
-    Mounted = "component:mount"
+import { RuntimeHost } from '../../types/runtime/runtime-host.types';
+import { RuntimeScopeHandle, RuntimeScopeLifecycleHooks, RuntimeScopeSnapshot, RuntimeScopeState } from '../../types/runtime/runtime-scope.types';
+import { RuntimeResourceBag } from './RuntimeResourceBag';
+export interface RuntimeScopeOptions {
+    id: string;
+    path: string;
+    boundaryId?: string;
+    parent?: RuntimeScope | null;
+    ownerRuntimeId?: string | null;
+    hooks?: RuntimeScopeLifecycleHooks;
 }
-export interface RuntimeEvents {
-    [RuntimeEventType.Mounted]: {
-        componentId: string;
-        storeKey?: string;
-    };
-}
-/**
- * Описывает контекст среды исполнения для некоторого сегмента.
- * Сегментом может быть setup-скрипт сценария, компонента или другие runtime-скрипты, JSX контексты.
- * Каждый сегмент связан с предыдущим - родительским (вложенность любая).
- */
-export declare class RuntimeScope extends EventBus<RuntimeEvents> {
+/** Runtime lifecycle owner для hosts, nested scopes и disposable resources. */
+export declare class RuntimeScope implements RuntimeScopeHandle {
     readonly id: string;
-    readonly parent?: RuntimeScope;
-    readonly vars: Map<string, any>;
-    readonly ui: {
-        componentMountedId?: string;
-        componentMountedStoreId?: string;
-    };
-    readonly export: {
-        names?: Record<string, CallableFunction>;
-    };
-    constructor(id: string, parent?: RuntimeScope);
-    /**
-     * Рекурсивный поиск экспортируемого имени
-     * ToDo: рекурсия? потомку доступны родительские методы?
-     */
-    findExportedFn(name: string): CallableFunction | undefined;
-    /**
-     * Получить значение переменной, пробрасываясь по родителям
-     */
-    getVar(name: string): any;
-    /**
-     * Массовая установка переменных
-     */
-    setVars(vars: Record<string, any> | Map<string, any>): void;
-    /**
-     * Проверка наличия переменной (с учётом родителя)
-     */
-    hasVar(name: string): boolean;
+    readonly path: string;
+    readonly boundaryId: string;
+    readonly parent: RuntimeScope | null;
+    readonly ownerRuntimeId: string | null;
+    readonly resources: RuntimeResourceBag;
+    state: RuntimeScopeState;
+    private readonly _hooks;
+    private readonly _children;
+    private readonly _members;
+    private _transition;
+    private _generation;
+    private _abortController;
+    private _updateGateOpen;
+    private _stale;
+    private _lastError;
+    private _activeChildrenBeforePause;
+    private readonly _listeners;
+    constructor(options: RuntimeScopeOptions);
+    get generation(): number;
+    get updateGateOpen(): boolean;
+    get stale(): boolean;
+    subscribe(listener: () => void): () => void;
+    activate(): Promise<void>;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    deactivate(): Promise<void>;
+    dispose(): Promise<void>;
+    addRuntime(host: RuntimeHost<any, any>): void;
+    removeRuntime(runtimeId: string): void;
+    markStale(): void;
+    acceptsUpdates(): boolean;
+    getRuntime(path: string): RuntimeHost<any, any> | null;
+    getOutput(name: string): unknown;
+    getChildren(): RuntimeScope[];
+    snapshot(): RuntimeScopeSnapshot;
+    private _resume;
+    private _safeDeactivate;
+    private _enqueue;
+    private _assertNotDisposed;
+    private _setError;
+    private _setState;
 }

package/dist/domain/entities/runtime/RuntimeScopeRegistry.d.ts

@@ -0,0 +1,24 @@
+import { RuntimeHost } from '../../types/runtime/runtime-host.types';
+import { RuntimeScope } from './RuntimeScope';
+/** Индексирует runtime scopes и membership RuntimeHost. */
+export declare class RuntimeScopeRegistry {
+    private readonly _scopes;
+    private readonly _scopeByRuntime;
+    private readonly _scopeDisposers;
+    private readonly _listeners;
+    private _transactionDepth;
+    private _notificationPending;
+    register(scope: RuntimeScope): RuntimeScope;
+    subscribe(listener: () => void): () => void;
+    transaction<T>(operation: () => T): T;
+    get(id: string): RuntimeScope | null;
+    getAll(): RuntimeScope[];
+    snapshot(): import('../../types/runtime').RuntimeScopeSnapshot[];
+    attachRuntime(scopeId: string, host: RuntimeHost<any, any>): void;
+    detachRuntime(runtimeId: string): void;
+    getByRuntime(runtimeId: string): RuntimeScope | null;
+    remove(id: string): Promise<void>;
+    reset(): Promise<void>;
+    private _changed;
+    private _notify;
+}

package/dist/domain/entities/runtime/hosts/ActionRuntimeHost.d.ts

@@ -1,5 +1,5 @@
 import { RAction } from '../../reflect/RAction';
-import { ActionRuntimeHostContext, RuntimeHost } from '../../../types/runtime-host.types';
+import { ActionRuntimeHostContext, RuntimeHost } from '../../../types/runtime/runtime-host.types';
 import { RuntimeHostBase } from '../RuntimeHostBase';
 /**
  * Создаёт контекст action-runtime с опциональной ссылкой на родительский контекст.

package/dist/domain/entities/runtime/hosts/ComponentSFCRuntimeHost.d.ts

@@ -0,0 +1,110 @@
+import { RComponentSFC } from '../../reflect/RComponentSFC';
+import { RComponentContract, RComponentDependencies, RComponentRenderTarget } from '../../../types/component/component-core.types';
+import { RComponentSFC_AST, RComponentSFC_IR, RComponentSFC_RuntimeDependencies, RComponentSFCSource_Parts, ComponentSFCEventOccurrence, ComponentSFCEventPort, ComponentSFCEventRuntimeSource } from '../../../types/component/sfc';
+import { ComponentSFCPreviewOptions, ComponentSFCProgramPayload, ProgramDiagnostic } from '../../../types/program/program.types';
+import { RuntimeArtifactReader, RuntimeHost, RuntimeHostContext, RuntimeHostInputSource, RuntimeHostUpdateContext } from '../../../types/runtime/runtime-host.types';
+import { ComputationResource } from '../../../types/computation';
+import { RuntimeHostBase } from '../RuntimeHostBase';
+/**
+ * Runtime-host нового SFC-компонента.
+ *
+ * Host хранит lifecycle/runtime-состояние и читает compiler-derived данные
+ * из `ProgramArtifact<ComponentSFCProgramPayload>`.
+ */
+export declare class ComponentSFCRuntimeHost extends RuntimeHostBase<'component-sfc', RuntimeHostContext<'component-sfc'>, ComponentSFCProgramPayload> {
+    private _inputSource;
+    private _raphInputDisposers;
+    private readonly _computationResources;
+    private readonly _computationErrorSignatures;
+    private _styleLease;
+    private readonly _eventPortListeners;
+    constructor(input: {
+        id: string;
+        model: RComponentSFC;
+        entityIdentity: string;
+        parent?: RuntimeHost<any, any> | null;
+        title?: string;
+        meta?: Record<string, unknown>;
+        artifactReader?: RuntimeArtifactReader | null;
+    });
+    /**
+     * LIFECYCLE
+     */
+    static createRuntime(input: {
+        id: string;
+        model: RComponentSFC;
+        meta?: Record<string, any>;
+        parent?: RuntimeHost<any, any> | null;
+        artifactReader?: RuntimeArtifactReader | null;
+    }): ComponentSFCRuntimeHost;
+    /** Возвращает разложенный canonical source из compiled artifact. */
+    getSourceParts(): RComponentSFCSource_Parts | null;
+    /** Возвращает diagnostics compiled artifact. */
+    getDiagnostics(): ProgramDiagnostic[];
+    /** Переводит public key через накопленный Composition catalog этого runtime. */
+    translate(key: string, fallback?: string): string;
+    /** Возвращает внешний контракт компонента из compiled artifact. */
+    getContract(): RComponentContract | null;
+    /** Возвращает зависимости компонента из compiled artifact. */
+    getDependencies(): RComponentDependencies | null;
+    /** Возвращает runtime-зависимости SFC v1 из compiled artifact. */
+    getRuntimeDependencies(): RComponentSFC_RuntimeDependencies;
+    /** Возвращает parser-level AST из compiled artifact. */
+    getAst(): RComponentSFC_AST | null;
+    /** Возвращает target-neutral semantic IR из compiled artifact. */
+    getIr(): RComponentSFC_IR | null;
+    /** Возвращает preview-only props из compiled artifact. */
+    getPreviewProps(): Record<string, unknown> | null;
+    /** Возвращает preview-only runtime options из compiled artifact. */
+    getPreviewOptions(): ComponentSFCPreviewOptions | null;
+    /** Subscribes to one public Event port of this mounted component instance. */
+    onEventPort(name: string, listener: (occurrence: ComponentSFCEventOccurrence) => void): () => void;
+    /** Emits an own/public Event through the root Component SFC boundary. */
+    emitEventPort(name: string, payload: unknown, source?: ComponentSFCEventRuntimeSource): Promise<void>;
+    /** Executes one compiler-linked Event reaction for a renderer boundary. */
+    executeEventPortAction(ownerIdentity: string, port: ComponentSFCEventPort, payload: unknown, source: ComponentSFCEventRuntimeSource | undefined, emitOwn: (name: string, payload: unknown, trace: string[], depth: number) => Promise<void>, trace?: string[], depth?: number): Promise<void>;
+    /** Publishes an already routed root Event without using the global Endge.events bus. */
+    publishEventPort(name: string, payload: unknown, source?: ComponentSFCEventRuntimeSource): void;
+    /** Returns one host-owned computation resource isolated by renderer consumer scope. */
+    getComputationResource(identity: string, input: unknown, consumerKey: string, portName?: string): ComputationResource;
+    /** Обновляет input source и пересобирает Raph subscriptions host-а. */
+    setInputSource(input: RuntimeHostInputSource | null | undefined): void;
+    /** Возвращает текущий input source host-а. */
+    getInputSource(): RuntimeHostInputSource | null;
+    /**
+     * Получает runtime update от universal boundary phase.
+     *
+     * Core не знает про DOM/Vue/RevoGrid: host только фиксирует update-факт
+     * и сообщает render adapter-у, что входные props нужно перечитать.
+     */
+    update(ctx: RuntimeHostUpdateContext): void;
+    pause(): void;
+    resume(): void;
+    /** Очищает Raph subscriptions перед общим destroy host-а. */
+    destroy(): void;
+    private _emitRootEventPort;
+    private _executeEventActionEffect;
+    private _reportComputationError;
+    /** Синхронизирует runtime context с текущим compiled artifact. */
+    syncArtifactState(target: RComponentRenderTarget | null): void;
+    /** Backward-compatible alias для старого runtime prepare API. */
+    preparePlaceholders(target: RComponentRenderTarget | null): void;
+    private makeArtifactResourcePayload;
+    private _createRuntimeBoundaryNodes;
+    private _createTableColumnBoundaryNode;
+    private _bindRaphInputSource;
+    private _bindRaphBoundaryInputSource;
+    private _isCoveredByPatchableBoundary;
+    private _findRuntimeNodeByMeta;
+    private _makeObservedColumnPaths;
+    private _makeBoundaryPatch;
+    private _makeTableRowPatch;
+    private _makeTableColumnPatch;
+    private _resolveBoundarySourcePath;
+    private _extractCollectionItemIndex;
+    private _extractChangedPath;
+    private _makeColumnProjection;
+    private _makeObservedRaphPaths;
+    private _clearRaphInputSubscriptions;
+    private _joinRaphPath;
+}

package/dist/domain/entities/runtime/hosts/CompositionRuntimeHost.d.ts

@@ -0,0 +1,124 @@
+import { RComposition } from '../../reflect/RComposition';
+import { FilterViewRuntimeHost } from './FilterViewRuntimeHost';
+import { CompositionFilterFieldsSlice, CompositionProgramPayload, CompositionPublicOutputHandle, CompositionRuntimeActivationHandle, CompositionRuntimeChildHandle } from '../../../types/source/composition-source.types';
+import { RuntimeArtifactReader, RuntimeHost, RuntimeHostContext, RuntimeHostInputSource, RuntimeHostUpdateContext } from '../../../types/runtime/runtime-host.types';
+import { I18nRuntimeCatalog } from '../../../types/i18n.types';
+import { RuntimeHostBase } from '../RuntimeHostBase';
+import { RuntimeScope } from '../RuntimeScope';
+/** Runtime orchestration host: children, bindings, hooks и public handles. */
+export declare class CompositionRuntimeHost extends RuntimeHostBase<'composition', RuntimeHostContext<'composition'>, CompositionProgramPayload> {
+    private _children;
+    private _childDescriptors;
+    private _publicOutputs;
+    private _scopes;
+    private _runtimeHandles;
+    private _outputBridges;
+    private _updateSourcePaths;
+    private _outputBridgeDisposers;
+    private _hookDisposers;
+    private _publicationDisposers;
+    private _disposers;
+    private _bridgePaths;
+    private _dataPaths;
+    private _storeRuntimeIds;
+    private _storeProviderRuntimeIds;
+    private _ownedStoreRuntimeIds;
+    private _compositionInputBindings;
+    private _i18nCatalogs;
+    private _orchestratedQueries;
+    private _orchestratedSuccesses;
+    private _mounted;
+    constructor(input: {
+        id: string;
+        model: RComposition;
+        parent?: RuntimeHost<any, any> | null;
+        meta?: Record<string, unknown>;
+        artifactReader: RuntimeArtifactReader;
+    });
+    static createRuntime(input: {
+        id: string;
+        model: RComposition;
+        meta?: Record<string, any>;
+        parent?: RuntimeHost<any, any> | null;
+        artifacts: RuntimeArtifactReader;
+    }): CompositionRuntimeHost | null;
+    /** Создает children, bindings и hooks. Повторный mount является no-op. */
+    mountGraph(): Promise<void>;
+    getChild(name: string): RuntimeHost<any, any> | null;
+    getChildren(): CompositionRuntimeChildHandle[];
+    getFilterFieldsSlice(runtimeName: string, fieldKeys: string[]): CompositionFilterFieldsSlice | null;
+    getOutputs(): Readonly<Record<string, CompositionPublicOutputHandle>>;
+    getScope(path: string): RuntimeScope | null;
+    /** Возвращает накопленный translation catalog для заданного lifecycle scope. */
+    getI18nCatalog(scopePath?: string): I18nRuntimeCatalog;
+    getRuntimeHandle(path: string): CompositionRuntimeActivationHandle | null;
+    /** Возвращает текущее значение публичного Composition output. */
+    getOutput(name: string): unknown;
+    /** Текущие значения data-блока для preview и runtime debugger. */
+    getDataSnapshot(): Readonly<Record<string, unknown>>;
+    /** Возвращает текущие значения публичных Composition props. */
+    getProps(): Readonly<Record<string, unknown>>;
+    /** Устанавливает literal/Raph-backed источник публичных Composition props. */
+    setInputSource(input: RuntimeHostInputSource | null | undefined): void;
+    /** Проверяет обязательные props до создания child runtime graph. */
+    private _assertRequiredProps;
+    /** Возвращает runtime Raph path объявленной data-зависимости. */
+    getDataPath(name: string, path?: string): string;
+    private _buildLifecycleScopes;
+    private _activateScope;
+    private _forgetScopeRuntimes;
+    private _forgetRuntime;
+    private _createRuntimeHandle;
+    private _requireScope;
+    private _prepareOutputBridges;
+    private _outputBridgeKey;
+    private _requireOutputBridge;
+    private _connectRuntimeOutputs;
+    private _disconnectRuntimeOutputs;
+    destroy(): Promise<void>;
+    /** Строит effective catalogs по той же иерархии, что и lifecycle scopes. */
+    private _buildI18nCatalogs;
+    /** Монтирует vocab data и разрешает Store aliases через explicit, ancestor или local provider. */
+    private _mountData;
+    /** Находит ближайший Store provider только среди Composition ancestors. */
+    private _findAncestorStoreProvider;
+    /** Публикует resolved Store instance для descendants этой Composition. */
+    private _registerStoreProvider;
+    /** Атомарно публикует накопленный batch runtime outputs в writable Store data. */
+    private _publishUpdates;
+    protected onUpdate(ctx: RuntimeHostUpdateContext): void;
+    private _requireDataPath;
+    private _createChild;
+    private _bindChild;
+    private _makeOutputs;
+    /** Не допускает прямые и транзитивные циклы Composition runtime tree. */
+    private _assertCompositionCycle;
+    private _bindHooks;
+    private _runQuery;
+    /** Запускает все одновременно готовые Query hooks одним parallel batch. */
+    private _runQueries;
+    private _runSuccessTargets;
+    private _successHookId;
+    private _readBinding;
+    private _compiledInputs;
+    /** Материализует authored bindings в единый runtime input source child Composition. */
+    private _makeInputSource;
+    private _subscribeBinding;
+    private _bindingPath;
+    private _materializeBinding;
+    /** Гарантирует, что список outputs для fromOutput(runtime) был связан до запуска runtime. */
+    private _requireResolvedOutputs;
+    /** Читает и распаковывает один именованный runtime output. */
+    private _readRuntimeOutput;
+    /** Собирает объект всех runtime outputs с сохранением их публичных имён. */
+    private _readRuntimeOutputs;
+    /** Читает весь compiled metadata map или один namespace сущности runtime alias-а. */
+    private _readRuntimeMetadata;
+    private _readExpressionSource;
+    private _collectExpressionReads;
+    private _subscribeExpressionRead;
+    private _readFilterFieldsBinding;
+    isFilterViewRuntime(runtime: RuntimeHost<any, any>): runtime is FilterViewRuntimeHost;
+    /** Возвращает topological runtime order по fromOutput dependencies. */
+    private _dependencyOrder;
+}

package/dist/domain/entities/runtime/hosts/FilterRuntimeHost.d.ts

@@ -0,0 +1,45 @@
+import { RFilter } from '../../reflect/RFilter';
+import { FilterProgramPayload, FilterRuntimeActionHandle, FilterRuntimeActionId, FilterRuntimeOutput } from '../../../types/source/filter-source.types';
+import { RuntimeArtifactReader, RuntimeHost, RuntimeHostContext } from '../../../types/runtime/runtime-host.types';
+import { SourceFieldDefinition } from '../../../types/source/source-expression.types';
+import { RuntimeHostBase } from '../RuntimeHostBase';
+/** Runtime-владелец Filter state, outputs и Actions. */
+export declare class FilterRuntimeHost extends RuntimeHostBase<'filter', RuntimeHostContext<'filter'>, FilterProgramPayload> {
+    private _outputs;
+    private _outputHashes;
+    constructor(input: {
+        id: string;
+        model: RFilter;
+        parent?: RuntimeHost<any, any> | null;
+        meta?: Record<string, unknown>;
+        artifactReader: RuntimeArtifactReader;
+    });
+    static createRuntime(input: {
+        id: string;
+        model: RFilter;
+        meta?: Record<string, any>;
+        parent?: RuntimeHost<any, any> | null;
+        artifacts: RuntimeArtifactReader;
+    }): FilterRuntimeHost | null;
+    /** Активирует зарегистрированный Filter host с восстановленным state. */
+    create(): void;
+    /** Восстанавливает persisted state после подключения runtime controller. */
+    private _hydratePersistence;
+    getState(): Readonly<Record<string, unknown>>;
+    get instanceName(): string;
+    getDefaults(): Readonly<Record<string, unknown>>;
+    getFields(): SourceFieldDefinition[];
+    getOutput(name: string): FilterRuntimeOutput | null;
+    getOutputs(): FilterRuntimeOutput[];
+    /** Возвращает вызываемый Action изменения Filter state. */
+    action(id: FilterRuntimeActionId): FilterRuntimeActionHandle;
+    private _patch;
+    private _set;
+    private _resetState;
+    private _replaceState;
+    private _recomputeOutputs;
+    private _normalizePatch;
+    private _isValidFieldValue;
+    private _isValidScalarValue;
+    private _outputHash;
+}

package/dist/domain/entities/runtime/hosts/FilterViewRuntimeHost.d.ts

@@ -0,0 +1,43 @@
+import { RFilter } from '../../reflect/RFilter';
+import { FilterRuntimeHost } from './FilterRuntimeHost';
+import { CompositionFilterFieldsSlice } from '../../../types/source/composition-source.types';
+import { FilterProgramPayload } from '../../../types/source/filter-source.types';
+import { FilterViewControlDefinition, FilterViewRenderModel } from '../../../types/ui/filter-view.type';
+import { RuntimeHost, RuntimeHostContext } from '../../../types/runtime/runtime-host.types';
+import { RuntimeHostBase } from '../RuntimeHostBase';
+/** Renderable UI-проекция одного Filter runtime без собственного filter state. */
+export declare class FilterViewRuntimeHost extends RuntimeHostBase<'filter', RuntimeHostContext<'filter'>, FilterProgramPayload> {
+    private readonly _sourceRuntime;
+    private readonly _sourceRuntimeName;
+    private readonly _fieldKeys;
+    private readonly _controls;
+    private readonly _implementation;
+    private readonly _onSourceChange;
+    private readonly _disposeSourceWatch;
+    private _props;
+    constructor(input: {
+        id: string;
+        name: string;
+        model: RFilter;
+        sourceRuntimeName: string;
+        sourceRuntime: FilterRuntimeHost;
+        fieldKeys?: string[];
+        controls?: Record<string, FilterViewControlDefinition>;
+        componentIdentity?: string;
+        props?: Record<string, unknown>;
+        parent?: RuntimeHost<any, any> | null;
+        meta?: Record<string, unknown>;
+    });
+    /** Возвращает renderer-neutral модель встроенного или пользовательского Filter view. */
+    getRenderModel(): FilterViewRenderModel;
+    /** Возвращает snapshot пользовательских presentation props. */
+    getProps(): Readonly<Record<string, unknown>>;
+    /** Атомарно обновляет presentation props и invalidates renderer. */
+    setProps(patch: Record<string, unknown>): void;
+    /** Меняет одно поле через state-владельца Filter runtime. */
+    setValue(key: string, value: unknown): Promise<void>;
+    /** Возвращает read-only slice для существующих fromFilter bindings. */
+    getSlice(): CompositionFilterFieldsSlice;
+    destroy(): void;
+    private _resolveControl;
+}

package/dist/domain/entities/runtime/hosts/PageRuntimeHost.d.ts

@@ -1,5 +1,5 @@
 import { RPage } from '../../reflect/RPage';
-import { RuntimeHost } from '../../../types/runtime-host.types';
+import { RuntimeHost } from '../../../types/runtime/runtime-host.types';
 import { RuntimeHostBase } from '../RuntimeHostBase';
 export declare class PageRuntimeHost extends RuntimeHostBase<'page'> {
     constructor(input: {

package/dist/domain/entities/runtime/hosts/ProjectRuntimeHost.d.ts

@@ -1,5 +1,5 @@
 import { RProject } from '../../reflect/RProject';
-import { RuntimeHost } from '../../../types/runtime-host.types';
+import { RuntimeHost } from '../../../types/runtime/runtime-host.types';
 import { RuntimeHostBase } from '../RuntimeHostBase';
 export declare class ProjectRuntimeHost extends RuntimeHostBase<'project'> {
     constructor(input: {

package/dist/domain/entities/runtime/hosts/QueryRuntimeHost.d.ts

@@ -1,22 +1,58 @@
 import { RQuery } from '../../reflect/RQuery';
-import { RuntimeHost } from '../../../types/runtime-host.types';
+import { QueryProgramPayload } from '../../../types/program/program.types';
+import { RuntimeArtifactReader, RuntimeHost, RuntimeHostContext, RuntimeHostUpdateContext } from '../../../types/runtime/runtime-host.types';
 import { RuntimeHostBase } from '../RuntimeHostBase';
-export declare class QueryRuntimeHost extends RuntimeHostBase<'query'> {
+/** Executable Query runtime с props, child filters и latest-wins. */
+export declare class QueryRuntimeHost extends RuntimeHostBase<'query', RuntimeHostContext<'query'>, QueryProgramPayload> {
+    private _props;
+    private _outputs;
+    private _outputHashes;
+    private _runSequence;
+    private _abortController;
+    private _filterChildIds;
+    private _derivedHandles;
+    private _outputWatchers;
+    private _outputPaths;
+    private _responseInputPaths;
+    private readonly _internalBase;
+    private _derivedErrorActive;
+    private _contextOff;
     constructor(input: {
         id: string;
         model: RQuery;
-        entityIdentity: string;
         parent?: RuntimeHost<any, any> | null;
-        title?: string;
         meta?: Record<string, unknown>;
+        artifactReader?: RuntimeArtifactReader;
+        entityIdentity?: string;
+        title?: string;
     });
-    /**
-     * LIFECYCLE
-     */
     static createRuntime(input: {
         id: string;
         model: RQuery;
         meta?: Record<string, any>;
         parent?: RuntimeHost<any, any> | null;
-    }): RuntimeHost<'query'> | null;
+        artifacts: RuntimeArtifactReader;
+    }): QueryRuntimeHost | null;
+    /** Активирует зарегистрированный Query host и создаёт его child filters. */
+    create(): void;
+    /** Создает unresolved Filter defaults после регистрации Query host. */
+    private _initializeDefaultSources;
+    getProps(): Readonly<Record<string, unknown>>;
+    setProps(patch: Record<string, unknown>): void;
+    getOutput(name: string): unknown;
+    getOutputs(): Readonly<Record<string, unknown>>;
+    run(propsPatch?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    pause(): void;
+    stop(): void;
+    reconcile(): Promise<void>;
+    destroy(): void;
+    protected onUpdate(ctx: RuntimeHostUpdateContext): void;
+    /** Монтирует compiled output graph как runtime-scoped Raph materialized dependencies. */
+    private _mountOutputGraph;
+    private _resolveOutputPath;
+    private _requireOutputPath;
+    private _requireResponseInputPath;
+    private _syncOutputs;
+    private _literalDefaults;
+    private _applyProps;
 }

package/dist/domain/entities/runtime/hosts/StoreRuntimeHost.d.ts

@@ -0,0 +1,38 @@
+import { RStore } from '../../reflect/RStore';
+import { RuntimeArtifactReader, RuntimeHost, RuntimeHostContext } from '../../../types/runtime/runtime-host.types';
+import { StoreDataDescriptor, StoreSourceArtifact } from '../../../types/source/store-source.types';
+import { RuntimeHostBase } from '../RuntimeHostBase';
+/** Runtime-владелец writable Store state и реактивных DataView projections. */
+export declare class StoreRuntimeHost extends RuntimeHostBase<'store', RuntimeHostContext<'store'>, StoreSourceArtifact> {
+    private _derivedHandles;
+    constructor(input: {
+        id: string;
+        model: RStore;
+        parent?: RuntimeHost<any, any> | null;
+        meta?: Record<string, unknown>;
+        artifactReader: RuntimeArtifactReader;
+        artifact: StoreSourceArtifact;
+    });
+    /** Создаёт Store runtime только из valid compiled artifact. */
+    static createRuntime(input: {
+        id: string;
+        model: RStore;
+        meta?: Record<string, any>;
+        parent?: RuntimeHost<any, any> | null;
+        artifacts: RuntimeArtifactReader;
+    }): StoreRuntimeHost | null;
+    /** Возвращает compiled descriptors Store fields. */
+    getFields(): StoreDataDescriptor[];
+    /** Возвращает абсолютный Raph path Store state или вложенного поля. */
+    getDataPath(path?: string): string;
+    /** Возвращает текущий снимок raw и derived Store fields. */
+    getDataSnapshot(): Readonly<Record<string, unknown>>;
+    /** Проверяет, можно ли записывать в root field указанного Store path. */
+    isWritable(path: string): boolean;
+    /** Записывает значение в writable Store field и запускает derived graph через Raph. */
+    set(path: string, value: unknown): void;
+    /** Освобождает derived registrations до удаления Store state. */
+    destroy(): void;
+    /** Инициализирует writable fields и затем immediate derived graph. */
+    private _mount;
+}