@endge/core 5.0.0 → 6.0.0

package/dist/features/core/modules/compiler/services/component-sfc/component-sfc-style.d.ts

@@ -0,0 +1,12 @@
+import { RComponentDiagnostic } from '../../../domain/types/component/component-core.types';
+import { RComponentSFC_AST_Style } from '../../../domain/types/component/sfc/ast.types';
+import { RComponentSFC_IR_Style } from '../../../domain/types/component/sfc/ir.types';
+export interface ComponentSFCStyleCompileResult {
+    style: RComponentSFC_IR_Style | null;
+    diagnostics: RComponentDiagnostic[];
+}
+export interface ComponentSFCStyleCompileOptions {
+    identity?: string;
+}
+/** Компилирует блок стилей SFC через тот же pipeline EndgeCSS, что и RStyle. */
+export declare function compileComponentSFCStyle(style: RComponentSFC_AST_Style | null, options?: ComponentSFCStyleCompileOptions): ComponentSFCStyleCompileResult;

package/dist/features/core/modules/compiler/services/component-sfc/component-sfc-table-menu.d.ts

@@ -0,0 +1,20 @@
+import { ComponentSFCTableCellMenuDescriptor, ComponentSFCTableColumnMenuDescriptor, ComponentSFCTableRowMenuDescriptor, RComponentSFC_IR_ElementNode } from '../../../domain/types/component/sfc/ir.types';
+import { ComponentSFCActionPort } from '../../../domain/types/component/sfc/ports.types';
+export declare const SFC_TABLE_COLUMN_MENU_MODES: readonly ["default", "disabled"];
+export type { ComponentSFCTableCellMenuDescriptor, ComponentSFCTableCellMenuMode, ComponentSFCTableColumnMenuDescriptor, ComponentSFCTableColumnMenuMode, ComponentSFCTableMenuDescriptor, ComponentSFCTableMenuItemDescriptor, ComponentSFCTableMenuNodeDescriptor, ComponentSFCTableMenuSeparatorDescriptor, ComponentSFCTableRowMenuDescriptor, ComponentSFCTableRowMenuMode, } from '../../../domain/types/component/sfc/ir.types';
+interface NormalizeMenuOptions {
+    availableActions?: ComponentSFCActionPort[];
+}
+/** Нормализует декларативное контекстное меню колонки без вычисления выражений SFC. */
+export declare function normalizeComponentSFCTableColumnMenu(tableNode: RComponentSFC_IR_ElementNode, actionsOrOptions?: ComponentSFCActionPort[] | NormalizeMenuOptions): ComponentSFCTableColumnMenuDescriptor;
+/** Нормализует необязательное меню строки. Значения ячеек остаются выражениями до правого клика. */
+export declare function normalizeComponentSFCTableRowMenu(tableNode: RComponentSFC_IR_ElementNode, actionsOrOptions?: ComponentSFCActionPort[] | NormalizeMenuOptions): ComponentSFCTableRowMenuDescriptor;
+/** Нормализует канонический Table > CellMenu с fallback на legacy Table > RowMenu. */
+export declare function normalizeComponentSFCTableCellMenu(tableNode: RComponentSFC_IR_ElementNode, actionsOrOptions?: ComponentSFCActionPort[] | NormalizeMenuOptions): ComponentSFCTableCellMenuDescriptor;
+/** Нормализует необязательное переопределение Column > CellMenu; `cell-menu="none"` отключает значение по умолчанию. */
+export declare function normalizeComponentSFCColumnCellMenu(tableNode: RComponentSFC_IR_ElementNode, columnNode: RComponentSFC_IR_ElementNode, actionsOrOptions?: ComponentSFCActionPort[] | NormalizeMenuOptions): ComponentSFCTableCellMenuDescriptor | undefined;
+/** Читает compile-time ссылку MenuItem на один порт Action. */
+export declare function readComponentSFCTableMenuActionPortReference(source: string): {
+    name: string;
+    role?: 'require' | 'provides';
+} | null;

package/dist/features/core/modules/compiler/services/component-sfc/component-sfc-table-pin.d.ts

@@ -0,0 +1,25 @@
+import { TableColumnPinSide } from '../../../actions/domain/action.types';
+import { RComponentDiagnostic } from '../../../domain/types/component/component-core.types';
+import { RComponentSFC_IR_ElementNode } from '../../../domain/types/component/sfc/ir.types';
+export declare const SFC_TABLE_COLUMN_PIN_MODES: readonly ["enabled", "disabled"];
+export declare const SFC_TABLE_COLUMN_PIN_SIDES: readonly ["left", "right"];
+export type ComponentSFCTableColumnPinMode = typeof SFC_TABLE_COLUMN_PIN_MODES[number];
+export type ComponentSFCTableColumnPinSide = typeof SFC_TABLE_COLUMN_PIN_SIDES[number];
+export interface ComponentSFCTableColumnPinStateItem {
+    key: string;
+    side: ComponentSFCTableColumnPinSide;
+}
+export interface ComponentSFCTableColumnPinDescriptor {
+    mode: ComponentSFCTableColumnPinMode;
+    defaultPin: ComponentSFCTableColumnPinStateItem[];
+    columns: ComponentSFCTableColumnPinCapability[];
+    diagnostics: RComponentDiagnostic[];
+}
+export interface ComponentSFCTableColumnPinCapability {
+    key: string;
+    pinnable: boolean;
+}
+/** Нормализует declarative pin props SFC Table без renderer-specific деталей. */
+export declare function normalizeComponentSFCTableColumnPin(tableNode: RComponentSFC_IR_ElementNode): ComponentSFCTableColumnPinDescriptor;
+export declare function normalizeComponentSFCTableColumnPinMode(value: unknown): ComponentSFCTableColumnPinMode;
+export declare function normalizeTableColumnPinSide(value: unknown): TableColumnPinSide;

package/dist/features/core/modules/compiler/services/component-sfc/component-sfc-table-sort.d.ts

@@ -0,0 +1,29 @@
+import { RComponentDiagnostic } from '../../../domain/types/component/component-core.types';
+import { RComponentSFC_IR_ElementNode } from '../../../domain/types/component/sfc/ir.types';
+export declare const SFC_TABLE_SORT_MODES: readonly ["multiple", "single", "fixed", "disabled"];
+export declare const SFC_TABLE_SORT_COMPARATORS: readonly ["natural", "text", "number", "date", "time", "boolean"];
+export declare const SFC_TABLE_SORT_DIRECTIONS: readonly ["asc", "desc"];
+export type ComponentSFCTableSortMode = typeof SFC_TABLE_SORT_MODES[number];
+export type ComponentSFCTableSortComparator = typeof SFC_TABLE_SORT_COMPARATORS[number];
+export type ComponentSFCTableSortDirection = typeof SFC_TABLE_SORT_DIRECTIONS[number];
+export interface ComponentSFCTableSortStateItem {
+    key: string;
+    direction: ComponentSFCTableSortDirection;
+}
+export interface ComponentSFCTableColumnSortDescriptor {
+    key: string;
+    sortable: boolean;
+    comparator: ComponentSFCTableSortComparator;
+    paths: string[];
+}
+export interface ComponentSFCTableSortDescriptor {
+    mode: ComponentSFCTableSortMode;
+    defaultSort: ComponentSFCTableSortStateItem[];
+    columns: ComponentSFCTableColumnSortDescriptor[];
+    diagnostics: RComponentDiagnostic[];
+}
+/** Нормализует декларативные sort props SFC Table из IR без выполнения пользовательского кода. */
+export declare function normalizeComponentSFCTableSort(tableNode: RComponentSFC_IR_ElementNode): ComponentSFCTableSortDescriptor;
+export declare function normalizeComponentSFCTableSortComparator(value: unknown): ComponentSFCTableSortComparator | null;
+export declare function normalizeComponentSFCTableSortMode(value: unknown): ComponentSFCTableSortMode;
+export declare function parseComponentSFCTableSortPaths(value: unknown, fallback: string): string[];

package/dist/features/core/modules/compiler/services/component-sfc/component-sfc-table-visibility.d.ts

@@ -0,0 +1,4 @@
+import { RComponentSFC_IR_ElementNode } from '../../../domain/types/component/sfc/ir.types';
+import { ComponentSFCTableColumnVisibilityDescriptor } from '../../../domain/types/component/sfc/table-visibility.types';
+/** Нормализует authored default-hidden без renderer-specific visibility state. */
+export declare function normalizeComponentSFCTableColumnVisibility(tableNode: RComponentSFC_IR_ElementNode): ComponentSFCTableColumnVisibilityDescriptor;

package/dist/features/core/modules/compiler/services/component-sfc/component-sfc-template.d.ts

@@ -0,0 +1,45 @@
+import { EndgeSFCEditingConfiguration } from '../../../configuration/domain/types/configuration.type';
+import { RComponentDependencies, RComponentDiagnostic } from '../../../domain/types/component/component-core.types';
+import { RComponentSFC_AST_Template } from '../../../domain/types/component/sfc/ast.types';
+import { RComponentSFC_IR_Template } from '../../../domain/types/component/sfc/ir.types';
+import { ComponentSFCComponentPort, ComponentSFCPortManifest, ComponentSFCPortProviderDescriptor, ComponentSFCRequiredPortKind } from '../../../domain/types/component/sfc/ports.types';
+import { ProgramNodeMetadata } from '../../../program/domain/types/program-metadata.types';
+/** Контекст компиляции template в IR. */
+export interface ComponentSFCTemplateCompileContext {
+    /** Имена props для классификации expression reads. */
+    props: string[];
+    /** Имена locals для классификации expression reads. */
+    locals: string[];
+    /** Порты локального компонента имеют приоритет над глобальным реестром пользовательских тегов. */
+    componentPorts?: ComponentSFCComponentPort[];
+    /** Обязательные порты, принадлежащие компилируемому Component SFC. */
+    ownerPorts?: ComponentSFCPortManifest | null;
+    /** Разрешает зарегистрированный пользовательский tag в identity компонента. */
+    resolveComponentTag?: (tag: string) => string | null;
+    /** Проверяет статическую identity из Component is. */
+    hasComponentIdentity?: (identity: string) => boolean;
+    /** Определяет публичные Events вложенного пользовательского Component для локальных bindings `@event`. */
+    resolveComponentPortManifest?: (identity: string) => ComponentSFCPortManifest | null;
+    /** Определяет статические провайдеры для плоских bindings дочерних портов. */
+    resolvePortProvider?: (identity: string, expectedKind: ComponentSFCRequiredPortKind) => ComponentSFCPortProviderDescriptor | null;
+    /** Определяет явные имена корневых Variant вложенного пользовательского компонента. */
+    resolveComponentVariants?: (identity: string) => string[] | null;
+    /** Effective defaults завершения edit session для текущего build context. */
+    sfcEditing?: EndgeSFCEditingConfiguration;
+}
+/** Результат компиляции template в IR. */
+export interface ComponentSFCTemplateCompileResult {
+    /** IR template или null, если template отсутствует. */
+    template: RComponentSFC_IR_Template | null;
+    /** Зависимости, найденные в template. */
+    dependencies: RComponentDependencies;
+    /** Диагностический проход template. */
+    diagnostics: RComponentDiagnostic[];
+    /** Публичная metadata внутренних template-узлов. */
+    metadata: ProgramNodeMetadata[];
+    /** Events, создаваемые декларативными реакциями template или редактируемым поведением. */
+    emittedEvents: string[];
+}
+export { isComponentSFCBuiltInTag } from './component-sfc-built-in-tags';
+/** Компилирует AST template в renderer-neutral Endge SFC IR. */
+export declare function compileComponentSFCTemplate(template: RComponentSFC_AST_Template | null, context: ComponentSFCTemplateCompileContext): ComponentSFCTemplateCompileResult;

package/dist/features/core/modules/compiler/services/computation/computation-compile.d.ts

@@ -0,0 +1,16 @@
+import { ComputationProgramPayload } from '../../../domain/types/computation/computation-program.types';
+import { ProgramDiagnostic } from '../../../program/domain/types/program.types';
+import * as t from '@babel/types';
+type DiagnosticDraft = Omit<ProgramDiagnostic, 'entityRef'>;
+export interface ComputationCompileInput {
+    source: string;
+}
+export interface ComputationCompileResult {
+    payload: ComputationProgramPayload;
+    diagnostics: DiagnosticDraft[];
+}
+/** Компилирует source defineComputation в детерминированный выходной граф. */
+export declare function compileComputation(input: ComputationCompileInput): ComputationCompileResult;
+export declare function validateSandboxBody(node: t.Node, diagnostics: DiagnosticDraft[], sourcePath: string): void;
+export declare function functionSource(node: t.ObjectMethod | t.FunctionExpression | t.ArrowFunctionExpression, source: string): string;
+export {};

package/dist/features/core/modules/compiler/services/type/type-program-validation.d.ts

@@ -0,0 +1,18 @@
+import { ProgramDiagnostic } from '../../../program/domain/types/program.types';
+import { TypeProgramCatalogEntry, TypeSourceDefinition, TypeSourceExpression } from '../../../source/domain/types/type-source.types';
+type DiagnosticDraft = Omit<ProgramDiagnostic, 'entityRef'>;
+/** Возвращает все именованные ссылки без раскрытия документа, на который они указывают. */
+export declare function collectTypeDefinitionReferences(definition: TypeSourceDefinition | null): string[];
+/** Возвращает все именованные ссылки из одного рекурсивного выражения типа Source. */
+export declare function collectTypeSourceExpressionReferences(expression: TypeSourceExpression | null | undefined): string[];
+/** Семантическая диагностика одного Type Source по скомпилированному доменному каталогу. */
+export declare function validateTypeDefinitionReferences(definition: TypeSourceDefinition | null, knownIdentities: ReadonlySet<string>): DiagnosticDraft[];
+/** Диагностика структурного inline-выражения типа, принадлежащего Query или другому Source-документу. */
+export declare function validateTypeSourceExpressionUsage(expression: TypeSourceExpression | null | undefined, catalog: readonly TypeProgramCatalogEntry[], sourcePath: string): DiagnosticDraft[];
+/** Диагностика выражения типа, принадлежащего Action, Computation, SFC или другому документу. */
+export declare function validateTypeExpressionUsage(expression: string | null | undefined, catalog: readonly TypeProgramCatalogEntry[], sourcePath: string): DiagnosticDraft[];
+/** Именованные ссылки реестра для индексации зависимостей Type Program. */
+export declare function collectTypeExpressionReferences(expression: string | null | undefined): Set<string>;
+/** Несоответствие контракта намеренно не блокирует работу во время миграции. */
+export declare function validateTypeCompatibility(expected: string | null | undefined, actual: string | null | undefined, sourcePath: string): DiagnosticDraft[];
+export {};

package/dist/features/core/modules/computations/EndgeComputations_Module.d.ts

@@ -0,0 +1,78 @@
+import { ImplementationBindingScope } from '../actions/domain/action.types';
+import { ComputationProgramPayload } from '../domain/types/computation/computation-program.types';
+import { ComputationOverride, ComputationSandboxAdapter, ComputationSandboxRequest } from '../domain/types/computation/computation-runtime.types';
+import { EntityOrigin } from '../domain/types/document/entity-management.type';
+import { EndgeImplementations_Module } from '../implementations/EndgeImplementations_Module';
+import { ProgramArtifact } from '../program/domain/types/program.types';
+import { ComputationResourceState } from './model/ComputationResource';
+import { EndgeModule } from '../../../federation/EndgeModule';
+/** Выполняет скомпилированные графы computation и создаёт нейтральные к renderer ресурсы. */
+export declare class EndgeComputations_Module extends EndgeModule {
+    private readonly _implementations;
+    private readonly _definitions;
+    private readonly _providers;
+    private readonly _providerDisposers;
+    private readonly _definitionDisposers;
+    private readonly _bindingDisposers;
+    private _sandbox;
+    private readonly _executor;
+    private readonly _api;
+    /**
+     * ----------------------------------------
+     * PUBLIC
+     * ----------------------------------------
+     */
+    constructor(_implementations: EndgeImplementations_Module);
+    hasDefinition(identity: string): boolean;
+    /** Устанавливает сериализуемое определение Computation из кода. */
+    define(definition: {
+        identity: string;
+        origin: EntityOrigin;
+        defaultProviderKey?: string;
+        execution?: 'sync' | 'async';
+    }): VoidFunction;
+    /** Устанавливает исполняемый код отдельно от определения Computation. */
+    provide(provider: {
+        identity: string;
+        key: string;
+        origin?: EntityOrigin;
+        implementation: ComputationOverride;
+    }): VoidFunction;
+    /** Выбирает ранее предоставленную реализацию без переопределения семантики. */
+    override(binding: {
+        identity: string;
+        providerKey: string;
+        scope?: Exclude<ImplementationBindingScope, 'default' | 'invocation'>;
+        scopeIdentity?: string;
+        priority?: number;
+    }): VoidFunction;
+    setSandboxAdapter(adapter: ComputationSandboxAdapter | null): void;
+    /** Выполняет уже проверенную компилятором функцию в общем изолированном sandbox. */
+    executeSandbox(request: ComputationSandboxRequest): Promise<unknown>;
+    run(idOrIdentity: string | number, input: unknown): Promise<unknown>;
+    runArtifact(artifact: ProgramArtifact<ComputationProgramPayload>, input: unknown): Promise<unknown>;
+    /**
+     * Компилирует и выполняет transient source без публикации в Endge.program.
+     *
+     * Используется редакторами и preview-инструментами для несохранённого draft.
+     */
+    runSource(source: string, input: unknown, identity?: string): Promise<unknown>;
+    runSync(idOrIdentity: string | number, input: unknown): unknown;
+    runArtifactSync(artifact: ProgramArtifact<ComputationProgramPayload>, input: unknown): unknown;
+    createResource(identity: string, input: unknown, _consumerKey: string): ComputationResourceState;
+    reset(): void;
+    /**
+     * ----------------------------------------
+     * PRIVATE
+     * ----------------------------------------
+     */
+    private _run;
+    private _runSync;
+    private _requireArtifact;
+    private _assertArtifact;
+    /** Создает child scope и блокирует runtime recursion или чрезмерно глубокий call graph. */
+    private _enterExecution;
+    private _runOverrideSync;
+    private _runOverride;
+    private _resolveProvider;
+}

package/dist/features/core/modules/computations/model/ComputationResource.d.ts

@@ -0,0 +1,27 @@
+import { ComputationResource as ComputationResourceContract, ComputationRuntimeErrorShape } from '../../domain/types/computation/computation-runtime.types';
+type AsyncRunner<T> = (input: unknown) => Promise<T>;
+type SyncRunner<T> = (input: unknown) => T;
+/** Нейтральное к renderer состояние latest-wins для одного consumer computation. */
+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/computation-runtime.types').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/features/core/modules/computations/model/ComputationResourceRegistry.d.ts

@@ -0,0 +1,11 @@
+import { ComputationResourceState } from './ComputationResource';
+import { ComputationResource as ComputationResourceContract } from '../../domain/types/computation/computation-runtime.types';
+/** Принадлежащий host реестр, изолирующий ресурсы по месту вызова и ключу consumer строки. */
+export declare class ComputationResourceRegistry {
+    private readonly _resources;
+    private readonly _disposers;
+    /** Входы ресурсов, запрошенные текущим активным проходом renderer. */
+    private readonly _updatingInputs;
+    getOrCreate(key: string, input: unknown, create: () => ComputationResourceState, onChange?: VoidFunction): ComputationResourceContract;
+    dispose(): void;
+}

package/dist/features/core/modules/computations/services/ComputationGraphExecutor.d.ts

@@ -0,0 +1,28 @@
+import { ComputationProgramPayload } from '../../domain/types/computation/computation-program.types';
+import { ComputationDependencyRunner, ComputationExecutionScope, ComputationSandboxAdapter } from '../../domain/types/computation/computation-runtime.types';
+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;
+    };
+}
+/** Выполняет упорядоченные компилятором графы computation без вычисления пользовательского JS в 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/features/core/modules/configuration/EndgeConfigurationSchema_Module.d.ts

@@ -0,0 +1,24 @@
+import { EndgeBootContext } from '../../kernel/types/bootstrap.types';
+import { EndgeConfigurationValues } from './domain/types/configuration.type';
+import { ProgramDiagnostic } from '../program/domain/types/program.types';
+import { EndgeConfigurationSchemaEntry } from '../source/domain/types/configuration-source.types';
+import { TypeProgramCatalogEntry } from '../source/domain/types/type-source.types';
+import { EndgeModule } from '../../../federation/EndgeModule';
+/** Компилирует схемы Configuration до разрешения фактического контекста. */
+export declare class EndgeConfigurationSchema_Module extends EndgeModule<EndgeBootContext> {
+    private _entries;
+    private _types;
+    private _valueDiagnostics;
+    build(_ctx: EndgeBootContext): void;
+    reset(): void;
+    list(): EndgeConfigurationSchemaEntry[];
+    get(identity: string): EndgeConfigurationSchemaEntry | null;
+    get typeCatalog(): TypeProgramCatalogEntry[];
+    get errors(): Array<{
+        identity: string;
+        diagnostic: Omit<ProgramDiagnostic, 'entityRef'>;
+    }>;
+    /** Применяет defaults, игнорирует устаревшие ключи и записывает несовместимые активные значения в Compiler Problems. */
+    resolveValues(input: EndgeConfigurationValues): EndgeConfigurationValues;
+    private _withValueDiagnostics;
+}

package/dist/features/core/modules/configuration/EndgeConfiguration_Module.d.ts

@@ -0,0 +1,29 @@
+import { EndgeBootContext } from '../../kernel/types/bootstrap.types';
+import { EndgeBuildContext, EndgeConfiguration, EndgeConfigurationContribution, EndgeConfigurationLayer } from './domain/types/configuration.type';
+import { EndgeModule } from '../../../federation/EndgeModule';
+/** Владеет effective configuration и immutable build context одного boot lifecycle. */
+export declare class EndgeConfiguration_Module extends EndgeModule<EndgeBootContext> {
+    private _current;
+    private _buildContext;
+    /** Разрешает Workspace - Tenant - Project - Environment до compiler build. */
+    build(ctx: EndgeBootContext): void;
+    /** Очищает effective configuration перед следующим boot. */
+    reset(): void;
+    /** Возвращает effective configuration текущего build. */
+    get current(): EndgeConfiguration;
+    /** Возвращает immutable compiler input текущего build. */
+    get buildContext(): EndgeBuildContext;
+    /** Показывает, завершено ли configuration resolution. */
+    get isResolved(): boolean;
+    /** Нормализует locale относительно effective configuration. */
+    normalizeLocale(locale: string | null | undefined): string;
+    /** Нормализует theme относительно effective configuration. */
+    normalizeTheme(theme: string | null | undefined): string;
+    /** Нормализует timezone относительно effective configuration. */
+    normalizeTimezone(timezone: string | null | undefined): string;
+    /** Вычисляет upstream snapshot для общего редактора указанного слоя. */
+    resolveUpstream(layer: EndgeConfigurationLayer): EndgeConfiguration;
+    /** Строит preview без изменения активной конфигурации запуска. */
+    preview(upstream: EndgeConfiguration, contribution: EndgeConfigurationContribution): EndgeConfiguration;
+    private _resolveEntity;
+}

package/dist/features/core/modules/configuration/domain/configuration-value.d.ts

@@ -0,0 +1,20 @@
+import { ProgramDiagnostic } from '../../program/domain/types/program.types';
+import { EndgeJSONValue } from '../../source/domain/types/configuration-source.types';
+import { TypeProgramCatalogEntry, TypeSourceExpression } from '../../source/domain/types/type-source.types';
+type DiagnosticDraft = Omit<ProgramDiagnostic, 'entityRef'>;
+export interface ConfigurationValueResult {
+    ok: boolean;
+    diagnostics: DiagnosticDraft[];
+}
+/** Проверяет одно сохранённое значение или default по фактическому Type Registry. */
+export declare function validateConfigurationValue(expression: TypeSourceExpression, value: unknown, catalog: readonly TypeProgramCatalogEntry[], sourcePath?: string): ConfigurationValueResult;
+/** Выводит детерминированный JSON default либо возвращает null, когда требуется явный ввод автора. */
+export declare function inferConfigurationDefault(expression: TypeSourceExpression, catalog: readonly TypeProgramCatalogEntry[], visiting?: Set<string>): {
+    ok: true;
+    value: EndgeJSONValue;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function isEndgeJSONValue(value: unknown): value is EndgeJSONValue;
+export {};

package/dist/features/core/modules/configuration/domain/endge-configuration.d.ts

@@ -0,0 +1,14 @@
+import { EndgeConfiguration, EndgeConfigurationContribution, EndgePublicConfigurationSnapshot } from './types/configuration.type';
+export declare const DEFAULT_ENDGE_CONFIGURATION: Readonly<EndgeConfiguration>;
+/** Создаёт независимую полную конфигурацию с системными defaults. */
+export declare function createDefaultEndgeConfiguration(): EndgeConfiguration;
+/** Нормализует и строго проверяет полную persisted-конфигурацию. */
+export declare function normalizeEndgeConfiguration(input: unknown): EndgeConfiguration;
+/** Нормализует contribution сущности; пустое значение означает чистое наследование. */
+export declare function normalizeEndgeConfigurationContribution(input: unknown): EndgeConfigurationContribution;
+/** Применяет один Project/Environment/Tenant contribution к upstream configuration. */
+export declare function applyEndgeConfigurationContribution(upstream: EndgeConfiguration, contribution: EndgeConfigurationContribution): EndgeConfiguration;
+/** Возвращает стабильный hash полного build context без platform crypto API. */
+export declare function createEndgeContextHash(input: unknown): string;
+/** Строит стабильную публичную проекцию SFC без внутренних vars, diagnostics и namespace storage. */
+export declare function createEndgePublicConfigurationSnapshot(configuration: EndgeConfiguration): EndgePublicConfigurationSnapshot;

package/dist/features/core/modules/configuration/domain/tooltip.config.d.ts

@@ -0,0 +1,3 @@
+import { EndgeTooltipConfiguration } from './types/configuration.type';
+/** Системные defaults, применяемые до переопределений Workspace -> Tenant -> Project -> Environment. */
+export declare const DEFAULT_ENDGE_TOOLTIP_CONFIGURATION: Readonly<EndgeTooltipConfiguration>;

package/dist/features/core/modules/configuration/domain/types/configuration.type.d.ts

@@ -0,0 +1,166 @@
+import { DiagnosticsSeverityNumber, DiagnosticsSignal, EndgeDiagnosticsConfiguration, EndgeDiagnosticsOutputConfiguration, EndgeDiagnosticsRoute } from '../../../diagnostics/domain/types/diagnostics.types';
+import { ComponentSFCInteractionKeyboardCondition, ComponentSFCInteractionTrigger } from '../../../domain/types/component/sfc/ir.types';
+import { EndgeExecutionContext } from '../../../runtime/domain/execution-context.types';
+import { EndgeJSONValue } from '../../../source/domain/types/configuration-source.types';
+export type EndgeConfigurationValues = Record<string, Record<string, EndgeJSONValue>>;
+export type EndgeConfigurationValuePatch = Record<string, Record<string, EndgeValueOverride<EndgeJSONValue>>>;
+export interface EndgeLocaleDefinition {
+    code: string;
+    displayName: string;
+    shortLabel: string;
+    direction?: 'ltr' | 'rtl';
+}
+export interface EndgeThemeDefinition {
+    identity: string;
+    displayName: string;
+}
+export interface EndgeTimezoneDefinition {
+    identity: string;
+    displayName: string;
+}
+export interface EndgeVariableDefinition {
+    name: string;
+    defaultValue: string;
+}
+/** Effective defaults завершения одной SFC edit session. */
+export interface EndgeSFCEditingConfiguration {
+    cancelOn: ComponentSFCInteractionTrigger[];
+    commitOn: ComponentSFCInteractionTrigger[];
+}
+export type EndgeTooltipSide = 'top' | 'right' | 'bottom' | 'left';
+export type EndgeTooltipAlign = 'start' | 'center' | 'end';
+/** Фактические defaults поведения единственного tooltip-слоя, принадлежащего Shell. */
+export interface EndgeTooltipConfiguration {
+    side: EndgeTooltipSide;
+    align: EndgeTooltipAlign;
+    openDelay: number;
+    closeDelay: number;
+    /** Необязательное состояние клавиатуры, требуемое при активации tooltip указателем или focus. */
+    keyboard?: ComponentSFCInteractionKeyboardCondition;
+}
+/** Полная конфигурация, с которой компилируется один Endge context. */
+export interface EndgeConfiguration {
+    vars: EndgeVariableDefinition[];
+    locales: EndgeLocaleDefinition[];
+    defaultLocale: string;
+    fallbackLocale: string;
+    themes: EndgeThemeDefinition[];
+    defaultTheme: string;
+    timezones: EndgeTimezoneDefinition[];
+    defaultTimezone: string;
+    defaultAuthProfileIdentity: string | null;
+    sfcAdapterIds: string[];
+    defaultSfcAdapterId: string;
+    /** Effective triggers, которые наследуют editable-узлы без локальных атрибутов. */
+    sfcEditing: EndgeSFCEditingConfiguration;
+    /** Фактическое поведение tooltip. Визуальные стили принадлежат CSS и хукам адаптера. */
+    tooltips: EndgeTooltipConfiguration;
+    /** Настройки telemetry, output adapters, routing и snapshots. */
+    diagnostics: EndgeDiagnosticsConfiguration;
+    /** Сохранённые и фактические значения, сгруппированные по идентификатору документа Configuration. */
+    values: EndgeConfigurationValues;
+}
+/** Глубоко readonly фактическая проекция конфигурации, доступная SFC. */
+export type EndgePublicConfigurationSnapshot = Readonly<Omit<EndgeConfiguration, 'vars' | 'diagnostics' | 'values'> & Record<string, unknown>>;
+export type EndgeValueOverride<T> = {
+    op: 'set';
+    value: T;
+} | {
+    op: 'remove';
+};
+/** Независимые override-операции SFC editing для одного configuration layer. */
+export interface EndgeSFCEditingConfigurationPatch {
+    cancelOn?: EndgeValueOverride<ComponentSFCInteractionTrigger[]>;
+    commitOn?: EndgeValueOverride<ComponentSFCInteractionTrigger[]>;
+}
+/** Переопределения tooltip уровня поля для одного слоя каскада конфигурации. */
+export interface EndgeTooltipConfigurationPatch {
+    side?: EndgeValueOverride<EndgeTooltipSide>;
+    align?: EndgeValueOverride<EndgeTooltipAlign>;
+    openDelay?: EndgeValueOverride<number>;
+    closeDelay?: EndgeValueOverride<number>;
+    keyboard?: EndgeValueOverride<ComponentSFCInteractionKeyboardCondition>;
+}
+export type EndgeCollectionPatchEntry<T> = {
+    key: string;
+    op: 'upsert';
+    value: T;
+} | {
+    key: string;
+    op: 'remove';
+};
+export interface EndgeCollectionPatch<T> {
+    entries: EndgeCollectionPatchEntry<T>[];
+}
+/** Локальные операции inherit-слоя. Отсутствующее поле наследуется без изменений. */
+export interface EndgeConfigurationPatch {
+    vars?: EndgeCollectionPatch<EndgeVariableDefinition>;
+    locales?: EndgeCollectionPatch<EndgeLocaleDefinition>;
+    defaultLocale?: EndgeValueOverride<string>;
+    fallbackLocale?: EndgeValueOverride<string>;
+    themes?: EndgeCollectionPatch<EndgeThemeDefinition>;
+    defaultTheme?: EndgeValueOverride<string>;
+    timezones?: EndgeCollectionPatch<EndgeTimezoneDefinition>;
+    defaultTimezone?: EndgeValueOverride<string>;
+    defaultAuthProfileIdentity?: EndgeValueOverride<string>;
+    sfcAdapterIds?: EndgeCollectionPatch<string>;
+    defaultSfcAdapterId?: EndgeValueOverride<string>;
+    sfcEditing?: EndgeSFCEditingConfigurationPatch;
+    tooltips?: EndgeTooltipConfigurationPatch;
+    /** Локальный contribution diagnostics для текущего configuration layer. */
+    diagnostics?: EndgeDiagnosticsConfigurationPatch;
+    /** Переопределения значений Configuration уровня поля, основанных на Source. */
+    values?: EndgeConfigurationValuePatch;
+}
+/** Patch локальной collection policy модуля диагностики. */
+export interface EndgeDiagnosticsCollectionPatch {
+    enabled?: EndgeValueOverride<boolean>;
+    signals?: EndgeCollectionPatch<DiagnosticsSignal>;
+    minSeverity?: EndgeValueOverride<DiagnosticsSeverityNumber>;
+    maxRecords?: EndgeValueOverride<number>;
+}
+/** Patch telemetry configuration с merge outputs и routes по стабильному id. */
+export interface EndgeDiagnosticsTelemetryPatch {
+    collection?: EndgeDiagnosticsCollectionPatch;
+    outputs?: EndgeCollectionPatch<EndgeDiagnosticsOutputConfiguration>;
+    routes?: EndgeCollectionPatch<EndgeDiagnosticsRoute>;
+}
+/** Patch состава диагностического snapshot. */
+export interface EndgeDiagnosticsSnapshotContentPatch {
+    telemetry?: EndgeValueOverride<boolean>;
+    problems?: EndgeValueOverride<boolean>;
+    configuration?: EndgeValueOverride<boolean>;
+}
+/** Patch условий автоматического snapshot. */
+export interface EndgeDiagnosticsAutomaticSnapshotPatch {
+    enabled?: EndgeValueOverride<boolean>;
+    errorCount?: EndgeValueOverride<number>;
+    windowSeconds?: EndgeValueOverride<number>;
+    cooldownSeconds?: EndgeValueOverride<number>;
+    outputIds?: EndgeCollectionPatch<string>;
+}
+/** Patch snapshots configuration текущего cascade layer. */
+export interface EndgeDiagnosticsSnapshotsPatch {
+    content?: EndgeDiagnosticsSnapshotContentPatch;
+    automatic?: EndgeDiagnosticsAutomaticSnapshotPatch;
+}
+/** Patch diagnostics configuration текущего cascade layer. */
+export interface EndgeDiagnosticsConfigurationPatch {
+    telemetry?: EndgeDiagnosticsTelemetryPatch;
+    snapshots?: EndgeDiagnosticsSnapshotsPatch;
+}
+export type EndgeConfigurationContribution = {
+    mode: 'inherit';
+    patch: EndgeConfigurationPatch;
+} | {
+    mode: 'replace';
+    value: EndgeConfiguration;
+};
+export type EndgeConfigurationLayer = 'workspace' | 'tenant' | 'project' | 'environment';
+/** Immutable input, передаваемый compiler strategies. */
+export interface EndgeBuildContext {
+    workspaceIdentity: string;
+    execution: EndgeExecutionContext;
+    configuration: EndgeConfiguration;
+    contextHash: string;
+}