@endge/core 4.0.3 → 6.0.0

package/dist/features/core/modules/runtime/RuntimeAppScope.d.ts

@@ -0,0 +1,61 @@
+import { RuntimeEntityType } from './domain/runtime-entity-map.types';
+import { RuntimeAppScopeExecuteOptions, RuntimeExecuteOptions } from './domain/runtime-execute.type';
+import { AnyRuntimeHost } from './domain/runtime-strategy.types';
+import { RuntimeExecutableModel } from './domain/runtime.types';
+export type RuntimeAppScopeCollisionPolicy = 'multi' | 'reject' | 'replace';
+export interface RuntimeAppScopeOptions {
+    /** Уникальный id scope внутри EndgeRuntime_Module. */
+    id: string;
+    /** Публичный корень runtime data в Raph. */
+    rootPath: string;
+    /** Политика повторного запуска root entity в этом scope. */
+    collisionPolicy?: RuntimeAppScopeCollisionPolicy;
+    /** Persistence policy по умолчанию для host-ов scope. */
+    persistence?: 'disabled' | 'local';
+}
+export interface RuntimeAppScopeAddress {
+    runtimeId: string;
+    localId: string;
+    runtimePath: string;
+}
+interface RuntimeAppScopeOwner {
+    execute: (model: RuntimeExecutableModel, options?: RuntimeExecuteOptions) => AnyRuntimeHost | null;
+    getRuntimeHostsByEntity: (entityType: RuntimeEntityType, entityIdentity: string, appScopeId?: string) => AnyRuntimeHost[];
+    destroyRuntimeTree: (runtimeId: string) => void;
+    destroyRuntimeTreeAsync: (runtimeId: string) => Promise<void>;
+}
+/**
+ * Изолированный корень runtime-приложения.
+ *
+ * Scope владеет публичным Raph namespace, политикой повторного запуска и
+ * автоматическим выделением локальных instance id. Caller не формирует
+ * глобальные runtime-id вручную.
+ */
+export declare class RuntimeAppScope {
+    readonly id: string;
+    readonly rootPath: string;
+    readonly collisionPolicy: RuntimeAppScopeCollisionPolicy;
+    readonly persistence: 'disabled' | 'local';
+    private readonly _owner;
+    private readonly _nextIndex;
+    constructor(owner: RuntimeAppScopeOwner, options: RuntimeAppScopeOptions);
+    /** Запускает entity в этом AppScope; root определяется отсутствием parent. */
+    execute(model: RuntimeExecutableModel, options?: RuntimeAppScopeExecuteOptions): AnyRuntimeHost | null;
+    /** Возвращает активный root runtime entity по domain identity. */
+    resolve<T = AnyRuntimeHost>(entityType: RuntimeEntityType, identity: string): T | null;
+    /** Удаляет runtime tree entity из этого scope. */
+    destroy(entityType: RuntimeEntityType, identity: string): void;
+    /** Удаляет runtime tree и ждёт полного освобождения lifecycle-ресурсов. */
+    destroyAsync(entityType: RuntimeEntityType, identity: string): Promise<void>;
+    /** Строит внутренний runtime id и независимый от него публичный Raph path. */
+    allocate(input: {
+        entityType: RuntimeEntityType;
+        identity: string;
+        explicitRuntimeId?: string | null;
+        requestedLocalId?: string | null;
+        scopeRoot: boolean;
+    }): RuntimeAppScopeAddress;
+    /** Сбрасывает automatic instance counters при reset общего runtime. */
+    reset(): void;
+}
+export {};

package/dist/features/core/modules/runtime/RuntimeBindingScope.d.ts

@@ -0,0 +1,48 @@
+import { RuntimeHost } from './domain/runtime-host.types';
+/**
+ * Минимальная binding-scope модель runtime.
+ * Хранит базовый путь и алиасы, от которых компоненты строят локальные selectors.
+ */
+export interface RuntimeBindingScope {
+    parentRuntimeId: string | null;
+    basePath: string | null;
+    aliases: Record<string, string>;
+}
+/**
+ * Привести unknown-значение к RuntimeBindingScope, если это возможно.
+ */
+export declare function asRuntimeBindingScope(value: unknown): RuntimeBindingScope | null;
+/**
+ * Собрать binding-scope для runtime.
+ * Если explicit scope не передан, пытается унаследовать scope родителя
+ * и только потом fallback-ится на legacy basePath.
+ */
+export declare function resolveRuntimeBindingScope(input: {
+    parent?: RuntimeHost<any, any> | null;
+    basePath?: string | null;
+    sourceVar?: string | null;
+    scope?: Partial<RuntimeBindingScope> | null;
+}): RuntimeBindingScope;
+/**
+ * Прочитать путь массива items из scope.
+ */
+export declare function getRuntimeScopeItemsPath(scope: RuntimeBindingScope): string;
+/**
+ * Прочитать шаблон пути строки из scope.
+ */
+export declare function getRuntimeScopeRowPath(scope: RuntimeBindingScope): string;
+/**
+ * Скомпилировать selector таблицы в абсолютный runtime path.
+ * Поддерживает:
+ * - legacy absolute: `$store...`
+ * - scope aliases: `@root.`, `@items.`, `@row.`
+ * - relative row selectors: `number`, `attrs[name='STA'].dateTime`
+ */
+export declare function resolveScopedTablePath(input: {
+    rawPath: string;
+    scope: RuntimeBindingScope;
+    rowIndex?: number;
+}): {
+    path: string;
+    vars: Record<string, any>;
+};

package/dist/features/core/modules/runtime/RuntimeHostBase.d.ts

@@ -0,0 +1,161 @@
+import { RaphNode } from '../../../../../../@endge-raph/dist/main.d.ts';
+import { RuntimeStateControllerLike } from '../context/domain/context-persistence.types';
+import { ProgramArtifact } from '../program/domain/types/program.types';
+import { RuntimeEntityModelMap, RuntimeEntityType } from './domain/runtime-entity-map.types';
+import { RuntimeArtifactReader, RuntimeHost, RuntimeHostArtifactRef, RuntimeHostCapability, RuntimeHostChannel, RuntimeHostContext, RuntimeHostInputBinding, RuntimeHostResource, RuntimeHostSnapshot, RuntimeHostStatus, RuntimeHostUpdateBinding, RuntimeHostUpdateContext } from './domain/runtime-host.types';
+import { RuntimeKind } from './domain/runtime.types';
+import { EventBus } from '@endge/utils';
+export declare abstract class RuntimeHostBase<TType extends RuntimeEntityType, TContext extends RuntimeHostContext<TType> = RuntimeHostContext<TType>, TArtifactPayload = unknown> extends EventBus<Record<string, any>> implements RuntimeHost<TType, TContext, TArtifactPayload> {
+    /** Уникальный runtime-id host. */
+    readonly id: string;
+    /** Родительский runtime-host для отладки вложенных запусков. */
+    parent: RuntimeHost<any, any> | null;
+    /** Канонический runtime kind host. */
+    readonly kind: RuntimeKind | 'runtime';
+    /** Техническое имя реализации host. */
+    readonly runtimeType: string;
+    /** Возможности runtime-host, доступные внешним consumers. */
+    readonly capabilities: readonly RuntimeHostCapability[];
+    /** Тип доменной сущности, к которой привязан host. */
+    readonly entityType: TType;
+    /** Экземпляр доменной модели, на которой работает host. */
+    readonly model: RuntimeEntityModelMap[TType];
+    /** Identity связанной доменной сущности. */
+    readonly entityIdentity: string;
+    /** Заголовок host для отображения в UI. */
+    readonly title: string;
+    /** Текущий статус жизненного цикла host. */
+    status: RuntimeHostStatus;
+    /** Время создания host (timestamp ms). */
+    readonly createdAt: number;
+    /** Время последнего изменения host (timestamp ms). */
+    updatedAt: number;
+    /** Ресурсы, ассоциированные с host. */
+    readonly resources: RuntimeHostResource[];
+    /** Каналы, используемые host для коммуникации. */
+    readonly channels: RuntimeHostChannel[];
+    /** Произвольные метаданные host. */
+    readonly meta: Record<string, unknown>;
+    /** Типизированный runtime-контекст host. */
+    context: TContext;
+    /** Корневая raph-нода host (первая добавленная). */
+    node: RaphNode | null;
+    /** Runtime-scoped namespace данных host. */
+    readonly basePath: string;
+    /** Контроллер persistence уровня runtime. */
+    runtimeState: RuntimeStateControllerLike | null;
+    /** Список raph-нод, которыми владеет host. */
+    private _raphNodes;
+    private _inputBindings;
+    private _updateBindings;
+    private _updateDisposers;
+    private _updateTimers;
+    private _quiesced;
+    /** Read-only доступ к compiled artifacts, если host связан с program artifact. */
+    private _artifactReader;
+    /** Ссылка на compiled artifact, связанный с host. */
+    private _artifactRef;
+    constructor(input: {
+        /** Уникальный runtime-id host. */
+        id: string;
+        /** Родительский runtime-host. */
+        parent?: RuntimeHost<any, any> | null;
+        /** Канонический runtime kind host. */
+        kind: RuntimeKind;
+        /** Техническое имя реализации host. */
+        runtimeType: string;
+        /** Возможности runtime-host, доступные внешним consumers. */
+        capabilities?: RuntimeHostCapability[];
+        /** Тип доменной сущности. */
+        entityType: TType;
+        /** Экземпляр доменной модели. */
+        model: RuntimeEntityModelMap[TType];
+        /** Identity доменной сущности. */
+        entityIdentity: string;
+        /** Отображаемое имя host. */
+        title?: string;
+        /** Стартовый статус host. */
+        status?: RuntimeHostStatus;
+        /** Начальные метаданные host. */
+        meta?: Record<string, unknown>;
+        /** Начальный контекст host (тип зависит от реализации). */
+        context?: TContext;
+        /** Read-only доступ к compiled artifacts. */
+        artifactReader?: RuntimeArtifactReader | null;
+        /** Ссылка на artifact, который обслуживает этот host. */
+        artifactRef?: RuntimeHostArtifactRef | null;
+    });
+    /**
+     * LIFECYCLE
+     */
+    create(): void;
+    mount(): void;
+    start(): void;
+    pause(): void;
+    resume(): void;
+    reconcile(): void;
+    stop(): void;
+    unmount(): void;
+    /** Останавливает доставку новых updates, не освобождая данные host-а. */
+    quiesce(): void;
+    /**
+     * LIFECYCLE
+     */
+    destroy(): void;
+    /**
+     * Обрабатывает универсальный runtime update.
+     *
+     * Базовая реализация только прокидывает событие наружу, а конкретный host
+     * решает, как обновлять свои данные, запросы или render-boundary.
+     */
+    update(ctx: RuntimeHostUpdateContext): void;
+    /** Логическая обработка update после разрешения binding-ов. */
+    protected onUpdate(ctx: RuntimeHostUpdateContext): Promise<void> | void;
+    statePath(path?: string): string;
+    outputPath(name: string): string;
+    bindInput(name: string, binding: RuntimeHostInputBinding): void;
+    readInput(name: string): unknown;
+    readInputs(): Readonly<Record<string, unknown>>;
+    bindUpdate(binding: RuntimeHostUpdateBinding): () => void;
+    private _unbindUpdate;
+    /**
+     * ACCESS
+     */
+    setStatus(status: RuntimeHostStatus): void;
+    /** Проверяет наличие runtime capability. */
+    hasCapability(capability: RuntimeHostCapability): boolean;
+    /**
+     * ACCESS
+     */
+    addResource(resource: RuntimeHostResource): void;
+    /**
+     * ACCESS
+     */
+    addChannel(channel: RuntimeHostChannel): void;
+    setContext(patch: Partial<TContext>): void;
+    replaceContext(context: TContext): void;
+    attachRuntimeState(runtimeState: RuntimeStateControllerLike | null): void;
+    /**
+     * ACCESS
+     */
+    addRaphNode(node: RaphNode): void;
+    /**
+     * ACCESS
+     */
+    getArtifact(): ProgramArtifact<TArtifactPayload> | null;
+    /** Возвращает read-only artifact reader текущей runtime session. */
+    getArtifactReader(): RuntimeArtifactReader | null;
+    /**
+     * ACCESS
+     */
+    getArtifactPayload(): TArtifactPayload | null;
+    /**
+     * ACCESS
+     */
+    snapshot(): RuntimeHostSnapshot;
+    /**
+     * ACCESS
+     */
+    protected touch(): void;
+    private _serializeContext;
+}

package/dist/features/core/modules/runtime/RuntimeHostFactory.d.ts

@@ -0,0 +1,15 @@
+import { RuntimeEntityModelMap, RuntimeEntityType } from './domain/runtime-entity-map.types';
+import { RuntimeHost } from './domain/runtime-host.types';
+export interface RuntimeHostFactoryInput<TType extends RuntimeEntityType> {
+    id: string;
+    entityType: TType;
+    model: RuntimeEntityModelMap[TType];
+    entityIdentity: string;
+    title?: string;
+    meta?: Record<string, unknown>;
+}
+export type RuntimeHostFactoryAnyInput = RuntimeHostFactoryInput<RuntimeEntityType>;
+/**
+ * ACCESS
+ */
+export declare function createRuntimeHost(input: RuntimeHostFactoryAnyInput): RuntimeHost<any>;

package/dist/features/core/modules/runtime/RuntimeHostRegistry.d.ts

@@ -0,0 +1,63 @@
+import { RuntimeEntityType } from './domain/runtime-entity-map.types';
+import { DestroyedRuntimeHostSnapshot, RuntimeHost } from './domain/runtime-host.types';
+import { RuntimeHostRegistryLike, RuntimeHostRegistrySnapshot } from './domain/runtime-registry.types';
+export declare class RuntimeHostRegistry implements RuntimeHostRegistryLike {
+    private _hosts;
+    private _indexByEntity;
+    private _childrenByParent;
+    private _parentByChild;
+    private _deletedSnapshots;
+    private _deletedSnapshotLimit;
+    /**
+     * ACCESS
+     */
+    register<T extends RuntimeHost<any, any>>(host: T): T;
+    /**
+     * ACCESS
+     */
+    getById(id: string): RuntimeHost<any, any> | null;
+    /**
+     * ACCESS
+     */
+    getAll(): RuntimeHost<any, any>[];
+    /** Возвращает runtime subtree в безопасном для destroy порядке: children first. */
+    getTreePostOrder(rootId: string): string[];
+    /**
+     * ACCESS
+     */
+    getByEntity(entityType: RuntimeEntityType, entityIdentity: string): RuntimeHost<any, any>[];
+    /**
+     * ACCESS
+     */
+    removeById(id: string): RuntimeHost<any, any> | null;
+    /**
+     * LIFECYCLE
+     */
+    clear(): void;
+    /**
+     * ACCESS
+     */
+    rememberDeletedSnapshot(snapshot: DestroyedRuntimeHostSnapshot): void;
+    /**
+     * ACCESS
+     */
+    getDeletedSnapshots(): DestroyedRuntimeHostSnapshot[];
+    /**
+     * ACCESS
+     */
+    removeDeletedSnapshot(id: string): DestroyedRuntimeHostSnapshot | null;
+    /**
+     * ACCESS
+     */
+    clearDeleted(): void;
+    setDeletedSnapshotLimit(limit: number): void;
+    private _trimDeletedSnapshots;
+    /**
+     * ACCESS
+     */
+    snapshot(): RuntimeHostRegistrySnapshot;
+    /**
+     * ACCESS
+     */
+    private _entityKey;
+}

package/dist/features/core/modules/runtime/RuntimeResourceBag.d.ts

@@ -0,0 +1,12 @@
+import { RuntimeOwnedResource, RuntimeResourceBagSnapshot } from './domain/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/features/core/modules/runtime/RuntimeScope.d.ts

@@ -0,0 +1,56 @@
+import { RuntimeHost } from './domain/runtime-host.types';
+import { RuntimeScopeHandle, RuntimeScopeLifecycleHooks, RuntimeScopeSnapshot, RuntimeScopeState } from './domain/runtime-scope.types';
+import { RuntimeResourceBag } from './RuntimeResourceBag';
+export interface RuntimeScopeOptions {
+    id: string;
+    path: string;
+    boundaryId?: string;
+    parent?: RuntimeScope | null;
+    ownerRuntimeId?: string | null;
+    hooks?: RuntimeScopeLifecycleHooks;
+}
+/** Runtime lifecycle owner для hosts, nested scopes и disposable resources. */
+export declare class RuntimeScope implements RuntimeScopeHandle {
+    readonly id: string;
+    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/features/core/modules/runtime/adapters/QueryExecutor_Adapter.d.ts

@@ -0,0 +1,57 @@
+import { AxiosInstance } from 'axios';
+import { AuthRequestPolicy, AuthResolvedSession, AuthResolveOptions } from '../../auth/domain/types/auth-profile.types';
+import { QueryProgramOutput } from '../../program/domain/types/program.types';
+import { QueryExecutionContext } from '../domain/query-execution.types';
+export interface QueryExecutorDependencies {
+    resolveVariable: (source: string) => string;
+    resolveAuth: (policy: AuthRequestPolicy, options?: AuthResolveOptions) => Promise<AuthResolvedSession>;
+    reportWarning: (message: string, data?: unknown) => void;
+}
+/** Выполняет source-only compiled query artifact. */
+export declare class QueryExecutor_Adapter {
+    private readonly _dependencies;
+    /** Transport capability для REST и GraphQL requests. */
+    private readonly _http;
+    /**
+     * ----------------------------------------
+     * PUBLIC
+     * ----------------------------------------
+     */
+    constructor(_dependencies: QueryExecutorDependencies, http?: AxiosInstance);
+    /** Выполняет только transport/mock слой; output graph материализует QueryRuntimeHost через Raph. */
+    execute(context: QueryExecutionContext): Promise<any>;
+    /** Извлекает response-backed source output без запуска DataView. */
+    readResponseOutput(output: QueryProgramOutput, response: unknown): unknown;
+    /**
+     * ----------------------------------------
+     * PRIVATE
+     * ----------------------------------------
+     */
+    /** Выбирает protocol executor по compiled artifact type. */
+    private _executeByProtocol;
+    /** Выполняет GraphQL operation и возвращает ее data, отделяя transport errors от GraphQL errors. */
+    private _runGraphQL;
+    /** Выполняет REST artifact. */
+    private _runRest;
+    private _throwHttpError;
+    /** Пишет краткую transport-индикацию без request body, headers и response payload. */
+    private _writeRequestError;
+    /** Публикует runtime warning безопасного expression evaluator. */
+    private _writeExpressionWarning;
+    private _asRecord;
+    /** Вычисляет скомпилированное выражение запроса с поддержкой legacy-полей статической нагрузки. */
+    private _evaluateRequestValue;
+    private _isSourceExpression;
+    private _asHeaders;
+    private _asOptionalNumber;
+    /** Читает mock payload из artifact. */
+    private _readMockData;
+    /** Читает dot-path из backend response без исключений. */
+    private _path;
+    /** Безопасно склеивает endpoint и path. */
+    private _buildUrl;
+    /** Применяет auth к headers или query params. */
+    private _applyAuth;
+    /** Разрешает environment placeholder через переданный composition owner. */
+    private _resolveVariable;
+}

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

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

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

@@ -0,0 +1,34 @@
+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';
+/**
+ * Канонический перечень сущностей, для которых может существовать runtime-host.
+ */
+export interface RuntimeEntityModelMap {
+    /** Доменная модель проекта. */
+    'project': RProject;
+    /** Доменная модель страницы. */
+    'page': RPage;
+    /** Доменная модель SFC-компонента нового API. */
+    'component-sfc': RComponentSFC;
+    /** Доменная модель запроса. */
+    'query': RQuery;
+    /** Source-first runtime для Filter. */
+    'filter': RFilter;
+    /** Граф оркестрации runtime. */
+    'composition': RComposition;
+    /** Source-first реактивный runtime Store. */
+    'store': RStore;
+    /** Внешний или эмулируемый нормализованный поток событий. */
+    'stream': RStream;
+    /** Доменная модель action. */
+    'action': RAction;
+}
+/** Дискриминатор типа runtime-сущности. */
+export type RuntimeEntityType = keyof RuntimeEntityModelMap;

package/dist/features/core/modules/runtime/domain/runtime-execute.type.d.ts

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