@endge/core 1.2.5

package/dist/domain/data-source-graphql.d.ts

@@ -0,0 +1,4 @@
+import { DataSource, ExecuteQueryContext } from './entities/data/DataSource';
+export declare class DataSourceGQL implements DataSource {
+    executeQuery<T>(ctx: ExecuteQueryContext): Promise<T>;
+}

package/dist/domain/data-source-mock.d.ts

@@ -0,0 +1,4 @@
+import { DataSource, ExecuteQueryContext } from './entities/data/DataSource';
+export declare class DataSourceMock implements DataSource {
+    executeQuery<T>(ctx: ExecuteQueryContext): Promise<T>;
+}

package/dist/domain/data-source-rest.d.ts

@@ -0,0 +1,4 @@
+import { DataSource, ExecuteQueryContext } from './entities/data/DataSource';
+export declare class DataSourceRest implements DataSource {
+    executeQuery<T>(ctx: ExecuteQueryContext): Promise<T>;
+}

package/dist/domain/declare/jsx.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Глобальный JSX-контекст для скриптов DSL
+ */
+declare const $: Record<string, any>;
+declare namespace JSX {
+    interface IntrinsicElements {
+        Text: {
+            children?: any;
+            bold?: boolean;
+            italic?: boolean;
+            underline?: boolean;
+            strike?: boolean;
+            color?: string;
+            bg?: string;
+            size?: string | number;
+            align?: string;
+            weight?: string;
+            shadow?: string;
+            uppercase?: boolean;
+            lowercase?: boolean;
+            capitalize?: boolean;
+            class?: string;
+        };
+        Layout: {
+            children?: any;
+            direction?: 'row' | 'column';
+            gap?: string | number;
+            align?: string;
+            justify?: string;
+            wrap?: boolean | string;
+            class?: string;
+        };
+        Icon: {
+            name: string;
+            size?: string | number;
+            color?: string;
+            class?: string;
+        };
+        Button: {
+            children?: any;
+            variant?: 'solid' | 'outline' | 'ghost';
+            color?: string;
+            onClick?: () => void;
+            class?: string;
+        };
+        Box: {
+            children?: any;
+            padding?: string;
+            margin?: string;
+            shadow?: string;
+            border?: string;
+            rounded?: boolean;
+            bg?: string;
+            class?: string;
+        };
+        Spacer: {
+            size?: string | number;
+        };
+        Image: {
+            src: string;
+            alt?: string;
+            width?: string | number;
+            height?: string | number;
+            rounded?: boolean;
+            class?: string;
+        };
+    }
+}

package/dist/domain/declare/scenario.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Декларация контекста для setup-скрипта сценария
+ */
+declare const UnsafeEndge: {
+    domain: any;
+    extract: any;
+    render: any;
+    store: any;
+    script: any;
+};
+declare function query(queryId: string): {
+    to(storeKey: string): Promise<void>;
+};
+declare function watch(queryId: string, seconds?: number): {
+    to(storeKey: string): Promise<void>;
+};
+declare function mount(componentId: string): {
+    from(storeKey: string): Promise<void>;
+};

package/dist/domain/dependency-graph.d.ts

@@ -0,0 +1,19 @@
+import { DataPath } from '@endge/raph';
+export declare class DependencyGraphBuilder {
+    id?: string;
+    parentId?: string;
+    vars: Set<string>;
+    fns: Set<string>;
+    varsPaths: Map<string, DataPath>;
+    children: DependencyGraphBuilder[];
+    constructor(id?: string);
+    /**
+     * Добавляет зависимости из JSX-строки (DSL-шаблон, Vue SFC,  ...)
+     */
+    addJSX(jsxCode: string): void;
+    private _walkAndNormalize;
+    private _normalizeDirectives;
+    private _generateVarPaths;
+    private _collectVars;
+    private _normalizeInterpolations;
+}

package/dist/domain/entities/action-flow/REndgeFlow.d.ts

@@ -0,0 +1,27 @@
+import { EndgeFlowDefinition, EndgeFlowNodeDefinition } from '../../types/endge-flow.types';
+declare class REndgeFlowNode {
+    id: string;
+    title: string;
+    blockId: string;
+    kind: EndgeFlowNodeDefinition['kind'];
+    params: Record<string, unknown>;
+    meta: Record<string, unknown>;
+}
+declare class REndgeFlowEdge {
+    id: string;
+    sourceNodeId: string;
+    sourcePortId: string;
+    targetNodeId: string;
+    targetPortId: string;
+    label: string | null;
+}
+export declare class REndgeFlow {
+    version: number;
+    entrypoint: string;
+    nodes: REndgeFlowNode[];
+    edges: REndgeFlowEdge[];
+    static createDefault(): REndgeFlow;
+    static fromPlain(json: Partial<EndgeFlowDefinition>): REndgeFlow;
+    toPlain(): EndgeFlowDefinition;
+}
+export {};

package/dist/domain/entities/data/DataSource.d.ts

@@ -0,0 +1,8 @@
+import { RQuery } from '../reflect/RQuery';
+export interface ExecuteQueryContext {
+    query: RQuery;
+    params: Record<string, any>;
+}
+export interface DataSource {
+    executeQuery<T>(ctx: ExecuteQueryContext): Promise<T>;
+}

package/dist/domain/entities/data/DependencyEdge.d.ts

@@ -0,0 +1,48 @@
+import { DependencyNode } from './DependencyNode';
+/**
+ * Представляет связь (ребро) в графе зависимостей между родительским компонентом
+ * и дочерним компонентом (или между двумя узлами одного компонента).
+ *
+ * Эта структура позволяет отследить, как данные из одного узла (переменной, поля)
+ * передаются или используются другим узлом (например, входом подкомпонента).
+ *
+ * @example
+ * // Пример 1: Прямая передача переменной из родителя в дочерний компонент
+ * const edge: DependencyEdge = {
+ *   from: parentVarNode,          // узел переменной "var1" в родителе
+ *   to: childVarNode,             // узел переменной "var_inner" в подкомпоненте
+ *   path: new DataPath('$'),      // эквивалентная передача без изменений
+ * }
+ *
+ * @example
+ * // Пример 2: Передача вложенного значения из объекта
+ * const edge: DependencyEdge = {
+ *   from: parentVarNode,          // родительский узел "user"
+ *   to: childVarNode,             // подкомпонентный узел "city"
+ *   path: new DataPath('address.city'), // путь до вложенного свойства
+ * }
+ *
+ * @example
+ * // Пример 3: Передача с переименованием (aliasMap может помочь явно указать соответствие)
+ * const edge: DependencyEdge = {
+ *   from: parentVarNode,
+ *   to: childVarNode,
+ *   path: new DataPath('$'),
+ * }
+ */
+export interface DependencyEdge {
+    /**
+     *  Информационное имя связи для отладки
+     */
+    name?: string;
+    /**
+     * Узел-источник (родительский узел или переменная),
+     * из которого берутся данные для передачи.
+     */
+    from: DependencyNode;
+    /**
+     * Узел-приемник (дочерний узел или вход подкомпонента),
+     * который будет использовать переданные данные.
+     */
+    to: DependencyNode;
+}

package/dist/domain/entities/data/DependencyGraph.d.ts

@@ -0,0 +1,25 @@
+import { DependencyNode } from './DependencyNode';
+import { RField } from '../reflect/RField';
+import { DependencyEdge } from './DependencyEdge';
+export declare class DependencyGraph {
+    private root;
+    private edges;
+    private errors;
+    private inputFields;
+    private exportedNames;
+    constructor(inputFields: Record<string, RField>, exportedNames: Set<string>);
+    getRoot(): DependencyNode;
+    getEdges(): DependencyEdge[];
+    getAllErrors(): string[];
+    addExpression(expression: string): void;
+    private _extractParts;
+    private _addPartsChain;
+    /**
+     * Ищет узел в графе по выражению вида "driver.lastName"
+     * (разбивает на части и идёт по дереву)
+     */
+    findNodeByPath(expression: string): DependencyNode | undefined;
+    findOrCreateNode(name: string, type?: string): DependencyNode;
+    findNodeByName(name: string, currentNode?: DependencyNode): DependencyNode | undefined;
+    addEdge(edge: DependencyEdge): void;
+}

package/dist/domain/entities/data/DependencyNode.d.ts

@@ -0,0 +1,30 @@
+import { RField } from '../reflect/RField';
+import { DataPath } from '@endge/raph';
+/**
+ * Узел зависимости
+ */
+export declare class DependencyNode {
+    name: string;
+    type: string;
+    children: DependencyNode[];
+    markers: Set<string>;
+    params: Map<string, Set<any>>;
+    /**
+     * Добавляет дочерний узел в дерево.
+     * Если такой уже есть (по name и type), мержит их детей и параметры.
+     */
+    addChild(newChild: DependencyNode): void;
+    /**
+     * Создаёт новый DependencyNode из RField.
+     */
+    static fromRField(field: RField): DependencyNode;
+    /**
+     * Создаёт дерево DependencyNode по dataPath.
+     * Обрабатывает параметры (params) и сохраняет их в виде множества.
+     */
+    static fromDataPath(dataPath: DataPath, baseType: string, parentNode?: DependencyNode): DependencyNode;
+    /**
+     * Помечает все узлы, которые соответствуют GraphQL-ответу.
+     */
+    markTouchedPaths(currentType: string, marker: string): void;
+}

package/dist/domain/entities/debug/MemoryStore.d.ts

@@ -0,0 +1,34 @@
+import { LogRecord } from '../../types/debug/base.types';
+/**
+ * Простое in-memory хранилище логов с ограничением по количеству
+ * и политикой удаления при переполнении.
+ */
+export declare class MemoryStore {
+    private limit;
+    private overflowPolicy;
+    private records;
+    constructor(limit?: number, overflowPolicy?: 'drop-oldest' | 'drop-new');
+    /**
+     * Добавляет запись в буфер.
+     * Если превышен лимит - применяет overflowPolicy:
+     *  - 'drop-oldest': удаляет первые элементы
+     *  - 'drop-new': игнорирует новую запись
+     */
+    push(record: LogRecord): void;
+    /**
+     * Возвращает все записи (копию массива).
+     */
+    all(): LogRecord[];
+    /**
+     * Полностью очищает буфер.
+     */
+    clear(): void;
+    /**
+     * Устанавливает новый лимит и политику.
+     */
+    setLimit(limit: number, policy?: 'drop-oldest' | 'drop-new'): void;
+    /**
+     * Текущее количество записей.
+     */
+    size(): number;
+}

package/dist/domain/entities/debug/tools/base.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Генерирует случайную шестнадцатеричную строку заданной длины.
+ * Пример: rndHex(8) - "a3f92b10"
+ */
+export declare function rndHex(length?: number): string;

package/dist/domain/entities/debug/tools/tree.d.ts

@@ -0,0 +1,12 @@
+import { LogRecord } from '../../../types/debug/base.types';
+import { LogNode } from '../../../types/debug/tree.types';
+/**
+ * Строит дерево:
+ *  - span_start - создаём SpanNode; если есть parentSpanId - вставляем как ребёнка, иначе в корень
+ *  - span_end   - дополняем соответствующий SpanNode (endTs/durMs)
+ *  - event      - кладём внутрь спана по corr.spanId; если не нашли - в корень (fallback)
+ *
+ * Никаких Trace-узлов здесь нет - корневыми узлами считаются «root spans»
+ * (те, у которых нет corr.parentSpanId).
+ */
+export declare function buildLogTree(records: LogRecord[]): LogNode[];

package/dist/domain/entities/diagnostics/DiagnosticsRecordStore.d.ts

@@ -0,0 +1,33 @@
+import { DiagnosticsRecord, DiagnosticsRecordKind } from '../../types/diagnostics.types';
+export declare class DiagnosticsRecordStore {
+    private _capacity;
+    private _slots;
+    private _head;
+    private _length;
+    private readonly _byId;
+    private readonly _traceIndex;
+    private readonly _entityIndex;
+    private readonly _channelIndex;
+    private readonly _recordsByKind;
+    private readonly _recordsByChannel;
+    constructor(capacity: number);
+    get size(): number;
+    setCapacity(nextCapacity: number): void;
+    append(record: DiagnosticsRecord): DiagnosticsRecord | null;
+    clear(): void;
+    toArray(limit?: number): DiagnosticsRecord[];
+    getById(recordId: number): DiagnosticsRecord | null;
+    getByTraceId(traceId: string, limit?: number): DiagnosticsRecord[];
+    getByEntity(type: string, id: string, limit?: number): DiagnosticsRecord[];
+    getByChannel(channel: string, limit?: number): DiagnosticsRecord[];
+    getRecordsByKind(): Partial<Record<DiagnosticsRecordKind, number>>;
+    getRecordsByChannel(): Record<string, number>;
+    private recordsFromIndex;
+    private addIndexes;
+    private removeRecord;
+    private addToIndex;
+    private removeFromIndex;
+    private toEntityKey;
+    private normalizeChannel;
+    private bumpCount;
+}

package/dist/domain/entities/diagnostics/DiagnosticsScopeHandle.d.ts

@@ -0,0 +1,21 @@
+import { DiagnosticsAttrs, DiagnosticsContextRef, DiagnosticsEventOptions, DiagnosticsLevel, DiagnosticsMeasurementOptions, DiagnosticsScopeOptions, DiagnosticsScopeWriter, DiagnosticsSnapshotOptions } from '../../types/diagnostics.types';
+export declare abstract class DiagnosticsScopeHandle {
+    protected readonly diagnostics: DiagnosticsScopeWriter;
+    protected readonly active: boolean;
+    protected readonly traceId: string;
+    protected readonly spanId: string | undefined;
+    protected readonly channel: string | undefined;
+    protected readonly level: DiagnosticsLevel;
+    protected readonly startedAt: number;
+    protected readonly attrs: DiagnosticsAttrs | undefined;
+    protected readonly entities: DiagnosticsScopeOptions['entities'];
+    protected readonly context: DiagnosticsContextRef | undefined;
+    protected _closed: boolean;
+    protected constructor(diagnostics: DiagnosticsScopeWriter, active: boolean, traceId: string, spanId: string | undefined, channel: string | undefined, level: DiagnosticsLevel, startedAt: number, attrs: DiagnosticsAttrs | undefined, entities: DiagnosticsScopeOptions['entities'], context: DiagnosticsContextRef | undefined);
+    get isActive(): boolean;
+    event(message: string, options?: DiagnosticsEventOptions): void;
+    measurement(name: string, value: number, options?: DiagnosticsMeasurementOptions): void;
+    snapshot(name: string, options?: DiagnosticsSnapshotOptions): void;
+    protected mergeContext(base: DiagnosticsContextRef | undefined, patch: Partial<DiagnosticsContextRef> | undefined): DiagnosticsContextRef | undefined;
+    protected normalizeChannel(value: string | undefined): string | undefined;
+}

package/dist/domain/entities/diagnostics/DiagnosticsSpan.d.ts

@@ -0,0 +1,9 @@
+import { DiagnosticsScopeHandle } from './DiagnosticsScopeHandle';
+import { DiagnosticsAttrs, DiagnosticsContextRef, DiagnosticsLevel, DiagnosticsScopeOptions, DiagnosticsSpanOwner } from '../../types/diagnostics.types';
+export declare class DiagnosticsSpan extends DiagnosticsScopeHandle {
+    private readonly _name;
+    private readonly _parentSpanId;
+    constructor(diagnostics: DiagnosticsSpanOwner, active: boolean, traceId: string, spanId: string | undefined, parentSpanId: string | undefined, name: string, channel: string | undefined, level: DiagnosticsLevel, startedAt: number, attrs: DiagnosticsAttrs | undefined, entities: DiagnosticsScopeOptions['entities'], context: DiagnosticsContextRef | undefined);
+    span(name: string, options?: DiagnosticsScopeOptions): DiagnosticsSpan;
+    end(attrs?: DiagnosticsAttrs): void;
+}

package/dist/domain/entities/diagnostics/DiagnosticsTrace.d.ts

@@ -0,0 +1,9 @@
+import { DiagnosticsScopeHandle } from './DiagnosticsScopeHandle';
+import { DiagnosticsSpan } from './DiagnosticsSpan';
+import { DiagnosticsAttrs, DiagnosticsContextRef, DiagnosticsLevel, DiagnosticsScopeOptions, DiagnosticsTraceOwner } from '../../types/diagnostics.types';
+export declare class DiagnosticsTrace extends DiagnosticsScopeHandle {
+    private readonly _name;
+    constructor(diagnostics: DiagnosticsTraceOwner, active: boolean, traceId: string, name: string, channel: string | undefined, level: DiagnosticsLevel, startedAt: number, attrs: DiagnosticsAttrs | undefined, entities: DiagnosticsScopeOptions['entities'], context: DiagnosticsContextRef | undefined);
+    span(name: string, options?: DiagnosticsScopeOptions): DiagnosticsSpan;
+    end(attrs?: DiagnosticsAttrs): void;
+}

package/dist/domain/entities/endge/EndgeActionJsonScript.d.ts

@@ -0,0 +1,2 @@
+export declare class EndgeActionJsonScript {
+}

package/dist/domain/entities/endge/EndgeApi.d.ts

@@ -0,0 +1,23 @@
+import { HttpMethod, RequestOptions, ServiceDescriptor } from '../../types/api.types';
+export declare function makeForm(data: Record<string, unknown>): URLSearchParams;
+/**
+ * Лёгкая axios-обёртка: JSON по умолчанию, query/headers/abort, генератор сервисов.
+ */
+export declare class EndgeApi {
+    private defaultHeaders;
+    private readonly client;
+    constructor(baseUrl: string, defaultHeaders?: Record<string, string>);
+    /** При необходимости можно динамически добавить/переопределить заголовки по умолчанию */
+    setDefaultHeaders(next: Record<string, string>): void;
+    /** Базовый метод запроса (axios.request) */
+    request<T>(method: HttpMethod, path: string, opts?: RequestOptions): Promise<T>;
+    get<T>(path: string, opts?: Omit<RequestOptions, 'body'>): Promise<T>;
+    post<T>(path: string, body?: unknown, opts?: Omit<RequestOptions, 'body'>): Promise<T>;
+    put<T>(path: string, body?: unknown, opts?: Omit<RequestOptions, 'body'>): Promise<T>;
+    patch<T>(path: string, body?: unknown, opts?: Omit<RequestOptions, 'body'>): Promise<T>;
+    delete<T>(path: string, opts?: Omit<RequestOptions, 'body'>): Promise<T>;
+    /**
+     * Генератор сервиса: по декларации возвращает объект с методами-эндпоинтами.
+     */
+    service<T extends Record<string, any>>(descriptor: ServiceDescriptor): T;
+}

package/dist/domain/entities/endge/EndgeEvent.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Базовая оболочка события, которую можно "отменить".
+ * Отмена может быть использована эмиттером для stopPropagation.
+ */
+export interface EndgeEventBase<T = unknown> {
+    readonly isCanceled: boolean;
+    readonly payload: T;
+    cancel: () => void;
+}
+/**
+ * Базовый класс события (cancellable envelope).
+ */
+export declare class EndgeEvent<T> implements EndgeEventBase<T> {
+    readonly payload: T;
+    isCanceled: boolean;
+    constructor(payload: T);
+    cancel(): void;
+}
+/**
+ * Опции эмита (для stopPropagation).
+ */
+export interface EndgeEmitOptions {
+    /**
+     * Если true - прекращает вызов следующих слушателей после cancel().
+     */
+    stopOnCancel?: boolean;
+}
+/**
+ * События ядра (строго типизированные) - подставь свой интерфейс payloads.
+ * Например:
+ * export interface EndgeEventPayloads { 'app:init': {}; ... }
+ */
+export type EndgeEventPayloads = Record<string, unknown>;

package/dist/domain/entities/endge/EndgeFederation.d.ts

@@ -0,0 +1,64 @@
+export type EndgeFederationModule = object;
+interface EndgeFederationHost {
+    isConfigured: boolean;
+    isSetup: boolean;
+    isInitialized: boolean;
+    isHydrating: boolean;
+    initPromise: Promise<void> | null;
+    modules: Map<string, EndgeFederationModule>;
+    state: Map<string, unknown>;
+}
+/**
+ * Общая статическая федерация модулей.
+ * Хост федерации живёт в `globalThis`, поэтому один и тот же класс
+ * остаётся singleton даже при загрузке из разных пакетов/бандлов.
+ */
+export declare abstract class EndgeFederation {
+    protected static readonly federationId: string;
+    protected static readonly storageKey: string | null;
+    private static readonly REGISTRY_KEY;
+    static get isInitialized(): boolean;
+    static get isLoadingFromStorage(): boolean;
+    /**
+     * Хук для одноразовой регистрации модулей в порядке вызова.
+     */
+    protected static configureFederation(): void;
+    /**
+     * Регистрирует модуль в федерации.
+     * Порядок регистрации определяет дальнейший порядок `setup/init/reset`.
+     */
+    static registerModule<T extends EndgeFederationModule>(key: string, module: T): T;
+    /**
+     * Выполняет `setup()` для всех модулей один раз до первого `init()`.
+     */
+    static setup(): Promise<void>;
+    /**
+     * Общий guard для одноразовой инициализации федерации.
+     */
+    protected static runInitialization(task: () => Promise<void>): Promise<void>;
+    /**
+     * Выполняет `init()` для всех зарегистрированных модулей.
+     */
+    protected static initModules(): Promise<void>;
+    /**
+     * Выполняет `reset()` у всех модулей и сбрасывает состояние федерации.
+     */
+    protected static resetModules(): Promise<void>;
+    /**
+     * Сохраняет сериализуемое состояние всех модулей в storage федерации.
+     */
+    static saveToStorage(): void;
+    /**
+     * Восстанавливает состояние модулей из storage федерации.
+     */
+    static loadFromStorage(): Record<string, unknown>;
+    protected static getModule<T>(key: string): T;
+    protected static getState<T>(key: string, factory: () => T): T;
+    protected static setState<T>(key: string, value: T): T;
+    protected static get host(): EndgeFederationHost;
+    private static runLifecycle;
+    private static getFederationId;
+    private static createHost;
+    private static registry;
+}
+export {};

package/dist/domain/entities/endge/EndgeModule.d.ts

@@ -0,0 +1,36 @@
+import { Subscribable } from '@endge/utils';
+/**
+ * Базовый модуль федерации.
+ * Все модули являются `Subscribable` и при необходимости могут уведомлять подписчиков через `notify()`.
+ */
+export declare abstract class EndgeModule extends Subscribable {
+    /**
+     * Подготавливает модуль к работе до основного `init()`.
+     * Используется для одноразовой настройки зависимостей, подписок и runtime-структур.
+     * Метод можно не переопределять.
+     */
+    setup(): void | Promise<void>;
+    /**
+     * Инициализирует модуль после `setup()` и после восстановления состояния федерации из storage.
+     * Основная загрузка данных и запуск runtime-логики должны происходить здесь.
+     * Метод можно не переопределять.
+     */
+    init(): void | Promise<void>;
+    /**
+     * Сбрасывает runtime-состояние модуля.
+     * После `reset()` федерация может быть повторно инициализирована тем же набором модулей.
+     * Метод можно не переопределять.
+     */
+    reset(): void | Promise<void>;
+    /**
+     * Возвращает сериализуемый snapshot модуля для сохранения федерацией.
+     * Если модулю нечего сохранять, можно вернуть `undefined` или не переопределять метод.
+     */
+    serialize(): unknown;
+    /**
+     * Восстанавливает состояние модуля из snapshot, полученного из storage федерации.
+     * `undefined` означает отсутствие сохранённого состояния и должен обрабатываться как дефолтный сценарий.
+     * Метод можно не переопределять.
+     */
+    deserialize(_payload: unknown): void;
+}

package/dist/domain/entities/endge/EndgeModuleController.d.ts

@@ -0,0 +1,18 @@
+export declare class EndgeModuleController {
+    /** Зарегистрированные подмодули: ключ -> модуль */
+    private _modules;
+    /** Флаг инициализации контроллера */
+    private _isInitialized;
+    /**
+     * Регистрирует подмодуль
+     */
+    registerModule(key: string, module: any): void;
+    /**
+     * Инициализация всех модулей
+     */
+    init(): void;
+    /**
+     * Сброс состояния всех модулей
+     */
+    reset(): void;
+}

package/dist/domain/entities/endge/EndgeSlotRegistry.d.ts

@@ -0,0 +1,14 @@
+import { VoidFunction } from '@endge/utils';
+export declare class EndgeSlotRegistry<T extends {
+    id?: string;
+}> {
+    private items;
+    private byId;
+    private listeners;
+    add(item: T): VoidFunction;
+    remove(item: T): void;
+    list(): readonly T[];
+    get(id: string): T | undefined;
+    subscribe(cb: () => void): VoidFunction;
+    private emit;
+}

package/dist/domain/entities/reflect/RAction.d.ts

@@ -0,0 +1,30 @@
+import { ActionCompiledFlow, ActionDefinition, ActionStepHandler, FlowValidationIssue } from '../../types/action.types';
+import { DuplicateOptions, REntity } from './REntity';
+import { RField } from './RField';
+/**
+ * Действие хранится как flow-описание.
+ * Атомарное действие = flow из одного шага.
+ */
+export declare class RAction extends REntity {
+    definition: ActionDefinition;
+    input: RField | null;
+    output: RField | null;
+    private readonly stepHandlers;
+    private _compiledFlow;
+    setStepHandler(runtimeId: string, fn: ActionStepHandler | undefined): void;
+    getStepHandler(runtimeId: string): ActionStepHandler | undefined;
+    hasStepHandler(runtimeId: string): boolean;
+    clearStepHandlers(): void;
+    private _normalizeDefinition;
+    private _buildCompiledFlow;
+    private _validateFlow;
+    private _fieldToPlain;
+    get compiledFlow(): ActionCompiledFlow | null;
+    getValidationIssues(): FlowValidationIssue[];
+    validate(): FlowValidationIssue[];
+    getCompiledRuntimeNodeId(runtimeId: string): string | null;
+    compile(): void;
+    run(): void;
+    toPlain(): Record<string, unknown>;
+    duplicate(options: DuplicateOptions): RAction;
+}

package/dist/domain/entities/reflect/RBehaviorBinding.d.ts

@@ -0,0 +1,19 @@
+import { EndgeBindingMode } from '../../types/resolve.types';
+import { REntity } from './REntity';
+/** Сущность биндинга поведения (коллекция behavior-bindings). */
+export declare class RBehaviorBinding extends REntity {
+    projectId: number | null;
+    ownerType: string;
+    ownerId: number | null;
+    targetType: string;
+    targetId: number | null;
+    eventName: string;
+    scriptRef: string;
+    mode: EndgeBindingMode;
+    priority: number;
+    isEnabled: boolean;
+    environmentId: number | null;
+    isInherited: boolean;
+    originBindingId: number | null;
+    toPlain(): Record<string, unknown>;
+}