@endge/core 5.0.0 → 7.0.0

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

@@ -0,0 +1,178 @@
+import { DiagnosticsSeverityNumber, DiagnosticsSignal, EndgeDiagnosticsConfiguration, EndgeDiagnosticsOutputConfiguration, EndgeDiagnosticsRoute } from '../../../diagnostics/domain/types/diagnostics.types';
+import { ComponentSFCInteractionKeyboardCondition, ComponentSFCInteractionTrigger, ComponentSFCInteractionTriggerActivation } 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>;
+    effectiveConfiguration?: EndgeValueOverride<boolean>;
+    domain?: EndgeValueOverride<boolean>;
+    program?: EndgeValueOverride<boolean>;
+    runtime?: EndgeValueOverride<boolean>;
+    raphData?: EndgeValueOverride<boolean>;
+    raphGraph?: EndgeValueOverride<boolean>;
+}
+/** Patch условий автоматического snapshot. */
+export interface EndgeDiagnosticsAutomaticSnapshotPatch {
+    enabled?: EndgeValueOverride<boolean>;
+    errorCount?: EndgeValueOverride<number>;
+    windowSeconds?: EndgeValueOverride<number>;
+    cooldownSeconds?: EndgeValueOverride<number>;
+    outputIds?: EndgeCollectionPatch<string>;
+}
+/** Patch snapshot, скачиваемого глобальной комбинацией клавиш. */
+export interface EndgeDiagnosticsShortcutSnapshotPatch {
+    triggerSet?: EndgeValueOverride<ComponentSFCInteractionTriggerActivation>;
+    content?: EndgeDiagnosticsSnapshotContentPatch;
+}
+/** Patch snapshots configuration текущего cascade layer. */
+export interface EndgeDiagnosticsSnapshotsPatch {
+    content?: EndgeDiagnosticsSnapshotContentPatch;
+    shortcut?: EndgeDiagnosticsShortcutSnapshotPatch;
+    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;
+}

package/dist/features/core/modules/context/EndgeContext_Module.d.ts

@@ -0,0 +1,170 @@
+import { EndgeBootContext } from '../../kernel/types/bootstrap.types';
+import { EndgeConfiguration } from '../configuration/domain/types/configuration.type';
+import { EndgeContextPersistenceConfig, EndgeContextSnapshot, EndgeKeyboardContextSnapshot, EndgePersistenceScope, EndgeRuntimeContextSnapshot, EndgeSessionIdentityProvider, EndgeStorageAdapter } from './domain/context-persistence.types';
+import { EndgeContextStateListener, EndgeContextStateTransform } from './domain/context-state.types';
+import { EndgePersistenceInput } from './persistence/EndgeStorageAdapterRegistry';
+import { EndgeExecutionContext, EndgeExecutionContextResolutionInput } from '../runtime/domain/execution-context.types';
+import { EndgeDataMode } from '../workspace/domain/workspace.types';
+import { RuntimeStateController } from './persistence/RuntimeStateController';
+import { EndgeModule } from '../../../federation/EndgeModule';
+/**
+ * Контекст выполнения Endge: текущий workspace/project/environment/user scope
+ * и координатор persistence-инфраструктуры приложения.
+ */
+export declare class EndgeContext_Module extends EndgeModule<EndgeBootContext> {
+    private readonly _adapters;
+    private readonly _runtimeControllers;
+    private readonly _stateListeners;
+    private _contextPersistence;
+    private _currentWorkspace;
+    private _currentTenant;
+    private _currentProject;
+    private _currentEnvironment;
+    private _currentUser;
+    private _currentLocale;
+    private _pendingLocale;
+    private _currentTheme;
+    private _themePreference;
+    private _currentTimezone;
+    private _pendingTimezone;
+    private _workspaceDataMode;
+    private _dataModeOverride;
+    private _sessionProvider;
+    private _isHydrating;
+    private _executionContextLocked;
+    /** Создаёт контекст, регистрирует storage adapters и восстанавливает snapshot. */
+    constructor();
+    /** Применяет explicit structural context до load/build остальных модулей. */
+    setup(ctx: EndgeBootContext): void;
+    /** Разрешает выбрать новый structural context только перед следующим boot. */
+    reset(): void;
+    /** Показывает, выполняется ли восстановление контекста из storage. */
+    get isLoadingFromStorage(): boolean;
+    /** Регистрирует storage adapter для persistence-контекста. */
+    registerStorageAdapter(adapter: EndgeStorageAdapter): void;
+    /** Настраивает persistence текущего контекста. */
+    configurePersistence(config: EndgeContextPersistenceConfig): void;
+    /** Устанавливает provider актуальных tenant и user identity. */
+    setSessionIdentityProvider(provider: EndgeSessionIdentityProvider | null): void;
+    /** Показывает, что Tenant принудительно задан authenticated session provider. */
+    get isTenantLockedBySession(): boolean;
+    /** Сериализует текущий execution scope в snapshot. */
+    createDiagnosticsSnapshot(): Record<string, unknown>;
+    serialize(): EndgeContextSnapshot;
+    /** Возвращает полный доступный SFC контекст без добавления временных значений в persistence. */
+    runtimeSnapshot(): EndgeRuntimeContextSnapshot;
+    /** Возвращает текущее временное состояние клавиатуры из общего пространства контекста Raph. */
+    getKeyboardState(): EndgeKeyboardContextSnapshot;
+    /** Публикует состояние клавиатуры UI-адаптера как узкие несохраняемые изменения Raph. */
+    setKeyboardState(input: EndgeKeyboardContextSnapshot): void;
+    /** Сохраняет подписчиков legacy-модуля и проецирует постоянные поля контекста в Raph. */
+    notify(): void;
+    /** Восстанавливает execution scope из snapshot с безопасными defaults. */
+    deserialize(payload: Partial<EndgeContextSnapshot> | undefined): void;
+    /** Сохраняет текущий context snapshot через выбранный adapter. */
+    saveToStorage(): void;
+    /** Загружает context snapshot из нового или legacy storage key. */
+    loadFromStorage(): EndgeContextSnapshot | undefined;
+    /** Возвращает полный persistence scope текущей сессии. */
+    getPersistenceScope(): EndgePersistenceScope;
+    /** Возвращает dynamic state текущего полного context scope. */
+    getState<T>(key: string, transform?: EndgeContextStateTransform<T>): T | undefined;
+    /** Сохраняет dynamic state в scope текущих workspace/tenant/project/environment/user. */
+    setState<T>(key: string, state: T, transform?: EndgeContextStateTransform<T>): void;
+    /** Удаляет dynamic state только из текущего полного context scope. */
+    removeState(key: string): void;
+    /** Подписывает потребителя на изменения одного dynamic state key. */
+    subscribeState(key: string, listener: EndgeContextStateListener): () => void;
+    /** Создаёт или возвращает controller runtime-состояния по runtime id. */
+    createRuntimeStateController(input: {
+        runtimeId: string;
+        storageId?: string;
+        persistence?: EndgePersistenceInput;
+    }): RuntimeStateController;
+    /** Возвращает runtime state controller по id. */
+    getRuntimeStateController(runtimeId: string): RuntimeStateController | null;
+    /** Удаляет runtime state controller из registry. */
+    destroyRuntimeStateController(runtimeId: string): void;
+    /** Возвращает identity текущего workspace. */
+    getCurrentWorkspace(): string | null;
+    /** Устанавливает текущий workspace и сохраняет контекст. */
+    setCurrentWorkspace(identity: string | null): void;
+    /** Возвращает identity текущего tenant с учётом session provider. */
+    getCurrentTenant(): string;
+    /** Устанавливает fallback identity текущего tenant. */
+    setCurrentTenant(identity: string | null): void;
+    /** Возвращает identity текущего project. */
+    getCurrentProject(): string;
+    /** Устанавливает текущий project и сохраняет контекст. */
+    setCurrentProject(identity: string | null): void;
+    /** Возвращает identity текущего environment. */
+    getCurrentEnvironment(): string;
+    /** Возвращает immutable structural coordinates текущего boot lifecycle. */
+    getExecutionContext(): EndgeExecutionContext;
+    /**
+     * Разрешает structural context после загрузки Domain, но до configuration/build.
+     * Explicit и session coordinates обязательны; сохранённые preferences могут
+     * безопасно перейти на первую доступную сущность, если Domain изменился.
+     */
+    resolveExecutionContext(input: EndgeExecutionContextResolutionInput): EndgeExecutionContext;
+    /** Устанавливает текущий environment и сохраняет контекст. */
+    setCurrentEnvironment(identity: string | null): void;
+    /** Возвращает identity текущего user с учётом session provider. */
+    getCurrentUser(): string;
+    /** Устанавливает fallback identity текущего user. */
+    setCurrentUser(identity: string | null): void;
+    /** Возвращает текущий режим выполнения данных для fixtures Store и внешних запусков Query. */
+    get dataMode(): EndgeDataMode;
+    /** Показывает, должны ли runtime-потребители вычислять сохранённые fixtures RMock. */
+    get isMockEnabled(): boolean;
+    /** Показывает, получен ли фактический режим из локального runtime-переопределения. */
+    get isDataModeOverridden(): boolean;
+    /** Применяет сохранённое значение Workspace по умолчанию без записи в локальное хранилище контекста. */
+    setWorkspaceDataMode(mode: EndgeDataMode): void;
+    /** Применяет принадлежащее host переопределение режима данных без перестроения структурного контекста. */
+    setDataMode(mode: EndgeDataMode): void;
+    /** Удаляет локальное переопределение и восстанавливает текущее значение Workspace по умолчанию. */
+    clearDataModeOverride(): void;
+    /** Упрощённый API для переключателей UI, представляющих mock-режим как boolean-состояние. */
+    setMockEnabled(enabled: boolean): void;
+    /** Возвращает текущую locale контекста. */
+    get currentLocale(): string;
+    /** Нормализует, сохраняет и публикует новую locale. */
+    setCurrentLocale(locale: string | null): void;
+    /** Согласует текущую locale с effective configuration после workspace resolution. */
+    reconcileCurrentLocaleWithWorkspace(configuration?: EndgeConfiguration): void;
+    /** Возвращает текущую тему контекста. */
+    get currentTheme(): string;
+    /** Нормализует, сохраняет и публикует пользовательскую тему. */
+    setCurrentTheme(theme: string | null): void;
+    /** Согласует сохранённую тему с effective configuration после workspace resolution. */
+    reconcileCurrentThemeWithWorkspace(configuration?: EndgeConfiguration): void;
+    /** Возвращает текущую временную зону контекста. */
+    get currentTimezone(): string;
+    /** Нормализует, сохраняет и публикует новую временную зону. */
+    setCurrentTimezone(timezone: string | null): void;
+    /** Согласует сохранённую временную зону с effective configuration. */
+    reconcileCurrentTimezoneWithWorkspace(configuration?: EndgeConfiguration): void;
+    /** Возвращает effective configuration либо persisted workspace configuration до resolution. */
+    private _activeConfiguration;
+    private _normalizeLocale;
+    private _normalizeTheme;
+    private _normalizeTimezone;
+    /** Сохраняет только явное предпочтение; фактическим значением по умолчанию продолжает владеть конфигурация. */
+    private _serializeForPersistence;
+    /** Выбирает storage adapter для заданной persistence policy. */
+    private _resolveAdapter;
+    private _notifyState;
+    private _warnStateFailure;
+    private _syncPersistentContextToRaph;
+    private _setRaphValueIfChanged;
+    /** Возвращает identity активного workspace для persistence scope. */
+    private _requireCurrentWorkspace;
+    /** Создаёт безопасный scope для контроллера, который не читает и не изменяет состояние. */
+    private _getDisabledPersistenceScope;
+    /** Вычисляет tenant и user identity текущей сессии. */
+    private _resolveSessionIdentity;
+    /** Обновляет одно поле scope и публикует изменение контекста. */
+    private _setScopeValue;
+    private _assertStructuralContextMutable;
+}

package/dist/features/core/modules/context/domain/context-persistence.types.d.ts

@@ -0,0 +1,84 @@
+import { EndgePublicConfigurationSnapshot } from '../../configuration/domain/types/configuration.type';
+export type EndgePersistenceDriver = 'local' | 'disabled';
+export interface EndgePersistenceOptions {
+    driver?: EndgePersistenceDriver;
+}
+export interface EndgeContextPersistenceConfig {
+    context?: EndgePersistenceDriver | EndgePersistenceOptions | null;
+}
+export interface EndgeContextSnapshot {
+    workspace: string | null;
+    tenant: string | null;
+    project: string | null;
+    environment: string | null;
+    user: string | null;
+    locale: string | null;
+    theme: string | null;
+    timezone: string | null;
+}
+/** Данные хранилища, отличающие явный выбор темы от фактического default. */
+export interface EndgePersistedContextSnapshot extends EndgeContextSnapshot {
+    themePreferenceVersion?: 1;
+}
+/** Временное состояние клавиатуры, предоставляемое активным UI-адаптером. */
+export interface EndgeKeyboardContextSnapshot {
+    platform: 'macos' | 'windows' | 'linux' | 'unknown';
+    modifiers: {
+        ctrl: boolean;
+        shift: boolean;
+        alt: boolean;
+        meta: boolean;
+        mod: boolean;
+        altGraph: boolean;
+    };
+    held: {
+        key: string[];
+        code: string[];
+    };
+}
+/** Полный readonly-контекст SFC. Временное состояние ввода намеренно не сериализуется. */
+export interface EndgeRuntimeContextSnapshot extends EndgeContextSnapshot {
+    /** Статическая фактическая конфигурация текущей сборки; не сохраняется и не поддерживается Raph. */
+    config: EndgePublicConfigurationSnapshot;
+    input: {
+        keyboard: EndgeKeyboardContextSnapshot;
+    };
+}
+export interface EndgePersistenceScope {
+    workspaceId: string;
+    tenantId: string;
+    projectId: string;
+    environmentId: string;
+    userId: string;
+}
+export type EndgePersistenceScopeResolver = () => EndgePersistenceScope;
+export interface EndgeSessionIdentity {
+    userId?: string | null;
+    tenantId?: string | null;
+}
+export interface EndgeSessionIdentityProvider {
+    getCurrentIdentity: () => EndgeSessionIdentity | null;
+}
+export interface EndgeStorageAdapter {
+    readonly id: EndgePersistenceDriver;
+    isAvailable: () => boolean;
+    read: <T>(key: string) => T | undefined;
+    write: <T>(key: string, value: T) => void;
+    remove: (key: string) => void;
+}
+export interface RuntimeStateDocument {
+    version: 1;
+    scope: EndgePersistenceScope;
+    runtimeId: string;
+    state: Record<string, Record<string, unknown>>;
+}
+export interface RuntimeStateControllerLike {
+    readonly runtimeId: string;
+    readonly storageId: string;
+    readonly storageKey: string;
+    readonly scope: EndgePersistenceScope;
+    get: <T>(entityKey: string, section: string, fallback: T) => T;
+    set: <T>(entityKey: string, section: string, value: T) => void;
+    remove: (entityKey: string, section?: string) => void;
+    clear: () => void;
+}

package/dist/features/core/modules/context/domain/context-state.types.d.ts

@@ -0,0 +1,12 @@
+import { ClassConstructor } from 'class-transformer';
+/** Ручное преобразование между runtime-состоянием и JSON-compatible представлением. */
+export interface EndgeContextStateCodec<T> {
+    serialize: (state: T) => unknown;
+    deserialize: (value: unknown) => T;
+}
+/**
+ * Способ преобразования dynamic state: class-transformer constructor либо ручной codec.
+ * Без transform значение сохраняется как обычное JSON-compatible значение.
+ */
+export type EndgeContextStateTransform<T> = ClassConstructor<T> | EndgeContextStateCodec<T>;
+export type EndgeContextStateListener = () => void;

package/dist/features/core/modules/context/endge-vars.d.ts

@@ -0,0 +1,81 @@
+import { EndgeResolvedWorkspaceVariable, EndgeWorkspaceVar } from '../workspace/domain/workspace.types';
+type EnvRecord = Record<string, unknown>;
+/**
+ * WorkspaceVariables resolves effective values of workspace variable definitions.
+ *
+ * Источник списка переменных:
+ *  - workspace.vars
+ *
+ * Источники значений и приоритеты:
+ *  1) ENVY/runtime vars (если задано) - самый высокий приоритет
+ *  2) Vite env: import.meta.env.VITE_<NAME> (напрямую, без сканирования)
+ *     - имя переменной внутри системы: без префикса (ENDPOINT_AUTH -> VITE_ENDPOINT_AUTH)
+ *  3) workspace.vars
+ *
+ * Runtime projections are owned by EndgeRuntime_Module, not by this service.
+ */
+export declare class WorkspaceVariables {
+    private readonly _getDefinitions;
+    private _envyRecord;
+    constructor(_getDefinitions: () => EndgeWorkspaceVar[]);
+    /**
+     * Устанавливает внешние overrides переменных и сразу пересинхронизирует Raph.
+     */
+    setEnvironment(envyRecord: EnvRecord): void;
+    /** Имя совместимости для вызывающего кода, который всё ещё напрямую передаёт runtime-переопределения. */
+    setEnvyRecord(envyRecord: EnvRecord): void;
+    /** Сохранённые определения переменных, принадлежащие Workspace. */
+    get definitions(): EndgeWorkspaceVar[];
+    /**
+     * Возвращает Domain Vars.
+     */
+    private _getDomainVars;
+    /**
+     * Порядок поиска:
+     *  1) ENVY
+     *  2) Vite env: import.meta.env.VITE_<NAME>
+     *  3) домен
+     */
+    getValue(name: string): string | undefined;
+    /**
+     * Возвращает все доменные переменные с учетом overrides.
+     */
+    getAll(): EndgeResolvedWorkspaceVariable[];
+    /**
+     * Возвращает переменные в виде record, удобном для сериализации и debug UI.
+     */
+    toRecord(): Record<string, {
+        defaultValue: string;
+        currentValue: string;
+    }>;
+    /**
+     * Резолвит одиночные токены и интерполирует несколько переменных в строке,
+     * затем применяет optional coercion.
+     */
+    resolve<T = string>(raw: unknown, options?: {
+        coerce?: (value: string | number | boolean | null | undefined) => T;
+        fallback?: T;
+        onInvalid?: 'fallback' | 'as-is' | 'throw';
+    }): T | undefined;
+    /**
+     * Приводит значение переменной к number.
+     */
+    static toNumber(v: unknown): number;
+    /**
+     * Приводит значение переменной к string.
+     */
+    static toString(v: unknown): string;
+    /**
+     * Приводит значение переменной к boolean.
+     */
+    static toBoolean(v: unknown): boolean;
+    /** Интерполирует все корректные `{{ VAR }}` и legacy `{VAR}` токены в строке. */
+    private _interpolate;
+    /**
+     * Внутренний helper модуля: parse Var Token.
+     */
+    private static _parseVarToken;
+    /** Читает variable из внешнего environment без изменения module state. */
+    private _getExternalValue;
+}
+export {};

package/dist/features/core/modules/context/persistence/EndgeStorageAdapterRegistry.d.ts

@@ -0,0 +1,9 @@
+import { EndgePersistenceDriver, EndgePersistenceOptions, EndgeStorageAdapter } from '../domain/context-persistence.types';
+export type EndgePersistenceInput = EndgePersistenceDriver | EndgePersistenceOptions | null | undefined;
+export declare function normalizePersistence(input: EndgePersistenceInput): EndgePersistenceOptions;
+export declare function normalizePersistenceDriver(value: unknown): EndgePersistenceDriver;
+export declare class EndgeStorageAdapterRegistry {
+    private readonly _adapters;
+    register(adapter: EndgeStorageAdapter): void;
+    resolve(input: EndgePersistenceInput): EndgeStorageAdapter;
+}

package/dist/features/core/modules/context/persistence/RuntimeStateController.d.ts

@@ -0,0 +1,24 @@
+import { EndgePersistenceScope, EndgePersistenceScopeResolver, EndgeStorageAdapter, RuntimeStateControllerLike } from '../domain/context-persistence.types';
+export declare function buildRuntimeStateStorageKey(scope: EndgePersistenceScope, runtimeId: string): string;
+export declare class RuntimeStateController implements RuntimeStateControllerLike {
+    readonly runtimeId: string;
+    readonly storageId: string;
+    private readonly _adapter;
+    private readonly _resolveScope;
+    constructor(input: {
+        runtimeId: string;
+        storageId?: string;
+        scope: EndgePersistenceScope | EndgePersistenceScopeResolver;
+        adapter: EndgeStorageAdapter;
+    });
+    /** Возвращает актуальный persistence scope, включая текущую session identity. */
+    get scope(): EndgePersistenceScope;
+    /** Строит storage key из актуального scope, чтобы переавторизация не сохраняла данные прежнему пользователю. */
+    get storageKey(): string;
+    get<T>(entityKey: string, section: string, fallback: T): T;
+    set<T>(entityKey: string, section: string, value: T): void;
+    remove(entityKey: string, section?: string): void;
+    clear(): void;
+    private _readDocument;
+    private _createDefaultDocument;
+}

package/dist/features/core/modules/context/persistence/adapters/DisabledContextAdapter.d.ts

@@ -0,0 +1,8 @@
+import { EndgeStorageAdapter } from '../../domain/context-persistence.types';
+export declare class DisabledContextAdapter implements EndgeStorageAdapter {
+    readonly id: "disabled";
+    isAvailable(): boolean;
+    read<T>(_key: string): T | undefined;
+    write<T>(_key: string, _value: T): void;
+    remove(_key: string): void;
+}

package/dist/features/core/modules/context/persistence/adapters/LocalStorageContextAdapter.d.ts

@@ -0,0 +1,10 @@
+import { EndgeStorageAdapter } from '../../domain/context-persistence.types';
+export declare class LocalStorageContextAdapter implements EndgeStorageAdapter {
+    readonly id: "local";
+    isAvailable(): boolean;
+    read<T>(key: string): T | undefined;
+    /** Читает legacy raw string, который ещё не использовал JSON serialization. */
+    readRaw(key: string): string | null;
+    write<T>(key: string, value: T): void;
+    remove(key: string): void;
+}

package/dist/features/core/modules/context/persistence/context-state.d.ts

@@ -0,0 +1,7 @@
+import { EndgePersistenceScope } from '../domain/context-persistence.types';
+import { EndgeContextStateTransform } from '../domain/context-state.types';
+/** Строит изолированный ключ dynamic state из полного context scope и ключа потребителя. */
+export declare function buildContextStateStorageKey(scope: EndgePersistenceScope, key: string): string;
+export declare function normalizeContextStateKey(value: unknown): string;
+export declare function serializeContextState<T>(state: T, transform?: EndgeContextStateTransform<T>): unknown;
+export declare function deserializeContextState<T>(value: unknown, transform?: EndgeContextStateTransform<T>): T;

package/dist/features/core/modules/converters/EndgeConverters_Module.d.ts

@@ -0,0 +1,42 @@
+import { ImplementationBindingScope } from '../actions/domain/action.types';
+import { EntityOrigin } from '../domain/types/document/entity-management.type';
+import { EndgeImplementations_Module } from '../implementations/EndgeImplementations_Module';
+import { EndgeModule } from '../../../federation/EndgeModule';
+type ConverterProvider = (value: unknown, options?: Record<string, unknown>) => unknown;
+/** Синхронно координирует definitions, providers и bindings конвертеров. */
+export declare class EndgeConverters_Module extends EndgeModule {
+    private readonly _implementations;
+    private readonly _definitions;
+    private readonly _providerDisposers;
+    private readonly _definitionDisposers;
+    private _started;
+    /**
+     * ----------------------------------------
+     * PUBLIC
+     * ----------------------------------------
+     */
+    constructor(_implementations: EndgeImplementations_Module);
+    has(identity: string): boolean;
+    define(definition: {
+        identity: string;
+        origin: EntityOrigin;
+        defaultProviderKey?: string;
+    }): VoidFunction;
+    provide(provider: {
+        identity: string;
+        key: string;
+        origin: EntityOrigin;
+        convert: ConverterProvider;
+    }): VoidFunction;
+    override(binding: {
+        identity: string;
+        providerKey: string;
+        scope?: Exclude<ImplementationBindingScope, 'default' | 'invocation'>;
+        scopeIdentity?: string;
+        priority?: number;
+    }): VoidFunction;
+    execute(identity: string, value: unknown, options?: Record<string, unknown>): unknown;
+    start(): void;
+    reset(): void;
+}
+export {};