@endge/core 5.0.0 → 7.0.0

package/dist/features/core/modules/runtime/hosts/FilterViewRuntimeHost.d.ts

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

package/dist/features/core/modules/runtime/hosts/PageRuntimeHost.d.ts

@@ -0,0 +1,22 @@
+import { RPage } from '../../domain/entities/RPage';
+import { RuntimeHost } from '../domain/runtime-host.types';
+import { RuntimeHostBase } from '../RuntimeHostBase';
+export declare class PageRuntimeHost extends RuntimeHostBase<'page'> {
+    constructor(input: {
+        id: string;
+        model: RPage;
+        entityIdentity: string;
+        parent?: RuntimeHost<any, any> | null;
+        title?: string;
+        meta?: Record<string, unknown>;
+    });
+    /**
+     * LIFECYCLE
+     */
+    static createRuntime(input: {
+        id: string;
+        model: RPage;
+        meta?: Record<string, any>;
+        parent?: RuntimeHost<any, any> | null;
+    }): RuntimeHost<'page'>;
+}

package/dist/features/core/modules/runtime/hosts/ProjectRuntimeHost.d.ts

@@ -0,0 +1,22 @@
+import { RProject } from '../../domain/entities/RProject';
+import { RuntimeHost } from '../domain/runtime-host.types';
+import { RuntimeHostBase } from '../RuntimeHostBase';
+export declare class ProjectRuntimeHost extends RuntimeHostBase<'project'> {
+    constructor(input: {
+        id: string;
+        model: RProject;
+        entityIdentity: string;
+        parent?: RuntimeHost<any, any> | null;
+        title?: string;
+        meta?: Record<string, unknown>;
+    });
+    /**
+     * LIFECYCLE
+     */
+    static createRuntime(input: {
+        id: string;
+        model: RProject;
+        meta?: Record<string, any>;
+        parent?: RuntimeHost<any, any> | null;
+    }): RuntimeHost<'project'>;
+}

package/dist/features/core/modules/runtime/hosts/QueryRuntimeHost.d.ts

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

package/dist/features/core/modules/runtime/hosts/StoreRuntimeHost.d.ts

@@ -0,0 +1,58 @@
+import { RStore } from '../../domain/entities/RStore';
+import { RuntimeArtifactReader, RuntimeHost, RuntimeHostContext } from '../domain/runtime-host.types';
+import { StoreDataDescriptor, StoreSourceArtifact } from '../../source/domain/types/store-source.types';
+import { StreamEventEnvelope } from '../../source/domain/types/stream-source.types';
+import { StoreMutationPlan } from '../../source/domain/types/update-source.types';
+import { RuntimeHostBase } from '../RuntimeHostBase';
+/** Runtime-владелец writable Store state и реактивных DataView projections. */
+export declare class StoreRuntimeHost extends RuntimeHostBase<'store', RuntimeHostContext<'store'>, StoreSourceArtifact> {
+    private _derivedHandles;
+    constructor(input: {
+        id: string;
+        model: RStore;
+        parent?: RuntimeHost<any, any> | null;
+        meta?: Record<string, unknown>;
+        artifactReader: RuntimeArtifactReader;
+        artifact: StoreSourceArtifact;
+    });
+    /** Создаёт Store runtime только из valid compiled artifact. */
+    static createRuntime(input: {
+        id: string;
+        model: RStore;
+        meta?: Record<string, any>;
+        parent?: RuntimeHost<any, any> | null;
+        artifacts: RuntimeArtifactReader;
+    }): StoreRuntimeHost | null;
+    /** Возвращает compiled descriptors Store fields. */
+    getFields(): StoreDataDescriptor[];
+    /** Возвращает абсолютный Raph path Store state или вложенного поля. */
+    getDataPath(path?: string): string;
+    /** Возвращает текущий снимок raw и derived Store fields. */
+    getDataSnapshot(): Readonly<Record<string, unknown>>;
+    /** Проверяет, можно ли записывать в root field указанного Store path. */
+    isWritable(path: string): boolean;
+    /** Проверяет принадлежность root field этому Store, включая derived field. */
+    isDeclared(path: string): boolean;
+    /** Записывает значение в writable Store field и запускает derived graph через Raph. */
+    set(path: string, value: unknown): void;
+    /**
+     * Маршрутизирует нормализованное событие по compile-time таблице Store.
+     * Возвращает false, если Store не объявляет Update для данного типа.
+     */
+    dispatch(event: StreamEventEnvelope): boolean;
+    /** Применяет именованный дочерний Update к Store без привязки к транспорту. */
+    applyUpdate(updateIdentity: string, payload: unknown): void;
+    /**
+     * Применяет inline mutation из Composition/UI.
+     * Это escape hatch для локальных изменений, которым не нужен persisted RUpdate.
+     */
+    applyMutation(plan: StoreMutationPlan): void;
+    /** Освобождает derived registrations до удаления Store state. */
+    destroy(): void;
+    /** Инициализирует writable fields и затем immediate derived graph. */
+    private _mount;
+    private _makeMutationPlans;
+    private _applyMutationPlan;
+    private _validateMetaPlan;
+    private _validateMutationPlans;
+}

package/dist/features/core/modules/runtime/hosts/StreamRuntimeHost.d.ts

@@ -0,0 +1,31 @@
+import { RStream } from '../../domain/entities/RStream';
+import { RuntimeArtifactReader, RuntimeHost, RuntimeHostContext } from '../domain/runtime-host.types';
+import { StreamTransportFactory } from '../domain/stream-runtime.types';
+import { StreamSourceArtifact } from '../../source/domain/types/stream-source.types';
+import { RuntimeHostBase } from '../RuntimeHostBase';
+/** Владелец lifecycle runtime для одного скомпилированного транспорта Stream. */
+export declare class StreamRuntimeHost extends RuntimeHostBase<'stream', RuntimeHostContext<'stream'>, StreamSourceArtifact> {
+    private _connection;
+    constructor(input: {
+        id: string;
+        model: RStream;
+        parent?: RuntimeHost<any, any> | null;
+        meta?: Record<string, unknown>;
+        artifactReader: RuntimeArtifactReader;
+        privateTransportFactory: StreamTransportFactory;
+    });
+    private readonly _transportFactory;
+    static createRuntime(input: {
+        id: string;
+        model: RStream;
+        meta?: Record<string, any>;
+        parent?: RuntimeHost<any, any> | null;
+        artifacts: RuntimeArtifactReader;
+        transportFactory: StreamTransportFactory;
+    }): StreamRuntimeHost | null;
+    start(): void;
+    stop(): void;
+    quiesce(): void;
+    destroy(): void;
+    private _receive;
+}

package/dist/features/core/modules/runtime/operation/EndgeOperations_Module.d.ts

@@ -0,0 +1,33 @@
+import { RuntimeHost } from '../domain/runtime-host.types';
+import { OperationHistory } from './operation-history';
+import { RuntimeScope } from '../RuntimeScope';
+import { EndgeModule } from '../../../../federation/EndgeModule';
+/** Определяет ближайшую активную Operation History по иерархии runtime-scope. */
+export declare class EndgeOperations_Module extends EndgeModule {
+    private readonly _histories;
+    private _latestScopeId;
+    private _keydownDisposer;
+    /**
+     * ----------------------------------------
+     * PUBLIC
+     * ----------------------------------------
+     */
+    register(scope: RuntimeScope, history: OperationHistory): () => void;
+    resolveForHost(host: RuntimeHost<any, any> | null | undefined): OperationHistory | null;
+    getActiveHistory(): OperationHistory | null;
+    undo(): Promise<unknown>;
+    redo(): Promise<unknown>;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    /** Возвращает безопасное summary зарегистрированных operation histories. */
+    createDiagnosticsSnapshot(): unknown;
+    /** Освобождает histories и глобальный keyboard listener текущего Runtime. */
+    reset(): void;
+    /**
+     * ----------------------------------------
+     * PRIVATE
+     * ----------------------------------------
+     */
+    private _ensureShortcuts;
+    private _disposeShortcuts;
+}

package/dist/features/core/modules/runtime/operation/operation-executor.d.ts

@@ -0,0 +1,17 @@
+import { OperationHistory } from './operation-history';
+export interface RuntimeOperationContext {
+    input: unknown;
+    runOutput?: unknown;
+    undoOutput?: unknown;
+}
+export interface ExecuteRuntimeOperationOptions {
+    id: string;
+    input: unknown;
+    history: OperationHistory | null;
+    recordHistory: boolean;
+    run: (context: RuntimeOperationContext) => Promise<unknown>;
+    undo: (context: RuntimeOperationContext) => Promise<unknown>;
+    redo?: ((context: RuntimeOperationContext) => Promise<unknown>) | null;
+}
+/** Выполняет один неизменяемый snapshot Operation и владеет общей семантикой курсора History. */
+export declare function executeRuntimeOperation(options: ExecuteRuntimeOperationOptions): Promise<unknown>;

package/dist/features/core/modules/runtime/operation/operation-history.d.ts

@@ -0,0 +1,54 @@
+import { ComponentSFCInteractionTrigger } from '../../domain/types/component/sfc/ir.types';
+import { RuntimeOwnedResource } from '../domain/runtime-resource.types';
+export interface OperationHistoryShortcutBinding {
+    command: 'undo' | 'redo';
+    triggers: ComponentSFCInteractionTrigger[];
+}
+export interface OperationHistoryEntry {
+    id: string;
+    input: unknown;
+    runOutput: unknown;
+    undo: () => Promise<unknown>;
+    redo: () => Promise<unknown>;
+    undoOutput?: unknown;
+}
+export interface OperationHistoryOptions {
+    id: string;
+    limit?: number;
+    shortcuts?: OperationHistoryShortcutBinding[] | null;
+    onChange?: () => void;
+}
+/** Курсор undo/redo в runtime-памяти. Переходы сериализованы, а ошибки не изменяют курсор. */
+export declare class OperationHistory implements RuntimeOwnedResource {
+    private readonly _options;
+    readonly kind = "operation-history";
+    readonly id: string;
+    private _entries;
+    private _cursor;
+    private _paused;
+    private _disposed;
+    private _queue;
+    private _limit;
+    constructor(_options: OperationHistoryOptions);
+    get limit(): number;
+    get shortcuts(): OperationHistoryShortcutBinding[];
+    get active(): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    setLimit(value: number): void;
+    commit(entry: OperationHistoryEntry): void;
+    undo(): Promise<unknown>;
+    redo(): Promise<unknown>;
+    pause(): void;
+    resume(): void;
+    dispose(): void;
+    snapshot(): {
+        limit: number;
+        cursor: number;
+        size: number;
+        paused: boolean;
+    };
+    private _enqueue;
+    private _trim;
+}
+export declare function defaultOperationHistoryShortcuts(): OperationHistoryShortcutBinding[];

package/dist/features/core/modules/runtime/services/RuntimeStrategyRegistry.d.ts

@@ -0,0 +1,11 @@
+import { AnyRuntimeStrategy } from '../domain/runtime-strategy.types';
+/** Реестр runtime strategy, которые EndgeRuntime_Module использует вместо switch/if factory. */
+export declare class RuntimeStrategyRegistry {
+    private readonly _strategies;
+    /** Регистрирует стратегию. Повторная регистрация с тем же id заменяет старую. */
+    register(strategy: AnyRuntimeStrategy): void;
+    /** Возвращает копию списка стратегий для диагностики. */
+    list(): AnyRuntimeStrategy[];
+    /** Подбирает первую стратегию, которая поддерживает модель. */
+    resolve(model: unknown): AnyRuntimeStrategy | null;
+}

package/dist/features/core/modules/runtime/services/SFCRenderInspectionSession.d.ts

@@ -0,0 +1,29 @@
+import { SFCRenderInspectionNode, SFCRenderInspectionNodeInput, SFCRenderInspectionSessionLike, SFCRenderInspectionTreeNode } from '../domain/sfc-render-inspection.type';
+/**
+ * Хранит opt-in проекцию живых SFC instances без зависимости от Vue, DOM или canvas.
+ */
+export declare class SFCRenderInspectionSession implements SFCRenderInspectionSessionLike {
+    private readonly _nodes;
+    private readonly _idsByStableKey;
+    private readonly _stableKeysById;
+    private readonly _listeners;
+    private _counter;
+    private _notifyPending;
+    /** Регистрирует или обновляет один instance и возвращает его opaque id. */
+    registerNode(input: SFCRenderInspectionNodeInput): string;
+    /** Удаляет instance после unmount renderer-owned physical node. */
+    unregisterNode(id: string): void;
+    /** Возвращает зарегистрированный instance по opaque id. */
+    getNode(id: string): SFCRenderInspectionNode | null;
+    /** Строит текущую иерархию без сохранения отдельного дублирующего дерева. */
+    getTree(runtimeId?: string): SFCRenderInspectionTreeNode[];
+    /** Подписывает UI на batched изменения inspection projection. */
+    subscribe(listener: () => void): VoidFunction;
+    /** Очищает instances одного runtime root. */
+    clearRuntime(runtimeId: string): void;
+    /** Полностью очищает короткоживущую debug session. */
+    clear(): void;
+    private _makeStableKey;
+    private _deleteNode;
+    private _scheduleNotify;
+}

package/dist/features/core/modules/runtime/services/strategies/ActionRuntimeStrategy.d.ts

@@ -0,0 +1,8 @@
+import { RuntimeStrategy } from '../../domain/runtime-strategy.types';
+import { RAction } from '../../../domain/entities/RAction';
+export declare class ActionRuntimeStrategy implements RuntimeStrategy<RAction> {
+    readonly id = "runtime:action";
+    readonly entityType = "action";
+    supports(model: unknown): model is RAction;
+    create(ctx: Parameters<RuntimeStrategy<RAction>['create']>[0]): import('../../domain/runtime-host.types').RuntimeHost<"action", import('../../domain/runtime-host.types').ActionRuntimeHostContext, unknown>;
+}

package/dist/features/core/modules/runtime/services/strategies/ComponentSFCRuntimeStrategy.d.ts

@@ -0,0 +1,9 @@
+import { RuntimeStrategy } from '../../domain/runtime-strategy.types';
+import { RComponentSFC } from '../../../domain/entities/RComponentSFC';
+import { ComponentSFCRuntimeHost } from '../../hosts/ComponentSFCRuntimeHost';
+export declare class ComponentSFCRuntimeStrategy implements RuntimeStrategy<RComponentSFC> {
+    readonly id = "runtime:component-sfc";
+    readonly entityType = "component-sfc";
+    supports(model: unknown): model is RComponentSFC;
+    create(ctx: Parameters<RuntimeStrategy<RComponentSFC>['create']>[0]): ComponentSFCRuntimeHost;
+}

package/dist/features/core/modules/runtime/services/strategies/CompositionRuntimeStrategy.d.ts

@@ -0,0 +1,9 @@
+import { RuntimeStrategy } from '../../domain/runtime-strategy.types';
+import { RComposition } from '../../../domain/entities/RComposition';
+import { CompositionRuntimeHost } from '../../hosts/CompositionRuntimeHost';
+export declare class CompositionRuntimeStrategy implements RuntimeStrategy<RComposition, CompositionRuntimeHost> {
+    readonly id = "runtime:composition";
+    readonly entityType: "composition";
+    supports(model: unknown): model is RComposition;
+    create(ctx: Parameters<RuntimeStrategy<RComposition, CompositionRuntimeHost>['create']>[0]): CompositionRuntimeHost | null;
+}

package/dist/features/core/modules/runtime/services/strategies/FilterRuntimeStrategy.d.ts

@@ -0,0 +1,9 @@
+import { RuntimeStrategy } from '../../domain/runtime-strategy.types';
+import { RFilter } from '../../../domain/entities/RFilter';
+import { FilterRuntimeHost } from '../../hosts/FilterRuntimeHost';
+export declare class FilterRuntimeStrategy implements RuntimeStrategy<RFilter, FilterRuntimeHost> {
+    readonly id = "runtime:filter";
+    readonly entityType: "filter";
+    supports(model: unknown): model is RFilter;
+    create(ctx: Parameters<RuntimeStrategy<RFilter, FilterRuntimeHost>['create']>[0]): FilterRuntimeHost | null;
+}

package/dist/features/core/modules/runtime/services/strategies/PageRuntimeStrategy.d.ts

@@ -0,0 +1,8 @@
+import { RuntimeStrategy } from '../../domain/runtime-strategy.types';
+import { RPage } from '../../../domain/entities/RPage';
+export declare class PageRuntimeStrategy implements RuntimeStrategy<RPage> {
+    readonly id = "runtime:page";
+    readonly entityType = "page";
+    supports(model: unknown): model is RPage;
+    create(ctx: Parameters<RuntimeStrategy<RPage>['create']>[0]): import('../../domain/runtime-host.types').RuntimeHost<"page", import('../../domain/runtime-host.types').PageRuntimeHostContext, unknown>;
+}

package/dist/features/core/modules/runtime/services/strategies/ProjectRuntimeStrategy.d.ts

@@ -0,0 +1,8 @@
+import { RuntimeStrategy } from '../../domain/runtime-strategy.types';
+import { RProject } from '../../../domain/entities/RProject';
+export declare class ProjectRuntimeStrategy implements RuntimeStrategy<RProject> {
+    readonly id = "runtime:project";
+    readonly entityType = "project";
+    supports(model: unknown): model is RProject;
+    create(ctx: Parameters<RuntimeStrategy<RProject>['create']>[0]): import('../../domain/runtime-host.types').RuntimeHost<"project", import('../../domain/runtime-host.types').ProjectRuntimeHostContext, unknown>;
+}

package/dist/features/core/modules/runtime/services/strategies/QueryRuntimeStrategy.d.ts

@@ -0,0 +1,9 @@
+import { RuntimeStrategy } from '../../domain/runtime-strategy.types';
+import { RQuery } from '../../../domain/entities/RQuery';
+import { QueryRuntimeHost } from '../../hosts/QueryRuntimeHost';
+export declare class QueryRuntimeStrategy implements RuntimeStrategy<RQuery, QueryRuntimeHost> {
+    readonly id = "runtime:query";
+    readonly entityType = "query";
+    supports(model: unknown): model is RQuery;
+    create(ctx: Parameters<RuntimeStrategy<RQuery>['create']>[0]): QueryRuntimeHost | null;
+}

package/dist/features/core/modules/runtime/services/strategies/StoreRuntimeStrategy.d.ts

@@ -0,0 +1,9 @@
+import { RuntimeStrategy } from '../../domain/runtime-strategy.types';
+import { RStore } from '../../../domain/entities/RStore';
+import { StoreRuntimeHost } from '../../hosts/StoreRuntimeHost';
+export declare class StoreRuntimeStrategy implements RuntimeStrategy<RStore, StoreRuntimeHost> {
+    readonly id = "runtime:store";
+    readonly entityType: "store";
+    supports(model: unknown): model is RStore;
+    create(ctx: Parameters<RuntimeStrategy<RStore, StoreRuntimeHost>['create']>[0]): StoreRuntimeHost | null;
+}

package/dist/features/core/modules/runtime/services/strategies/StreamRuntimeStrategy.d.ts

@@ -0,0 +1,12 @@
+import { RuntimeStrategy } from '../../domain/runtime-strategy.types';
+import { ResolveAuthSession } from '../transports/BrowserSseStreamTransportFactory';
+import { RStream } from '../../../domain/entities/RStream';
+import { StreamRuntimeHost } from '../../hosts/StreamRuntimeHost';
+export declare class StreamRuntimeStrategy implements RuntimeStrategy<RStream, StreamRuntimeHost> {
+    private readonly _resolveAuthSession;
+    readonly id = "runtime:stream";
+    readonly entityType: "stream";
+    constructor(_resolveAuthSession: ResolveAuthSession);
+    supports(model: unknown): model is RStream;
+    create(ctx: Parameters<RuntimeStrategy<RStream, StreamRuntimeHost>['create']>[0]): StreamRuntimeHost | null;
+}

package/dist/features/core/modules/runtime/services/transports/BrowserSseStreamTransportFactory.d.ts

@@ -0,0 +1,9 @@
+import { AuthRequestPolicy, AuthResolvedSession, AuthResolveOptions } from '../../../auth/domain/types/auth-profile.types';
+import { StreamTransportConnection, StreamTransportFactory } from '../../domain/stream-runtime.types';
+export type ResolveAuthSession = (policy: AuthRequestPolicy, options?: AuthResolveOptions) => Promise<AuthResolvedSession>;
+/** Браузерный адаптер, владеющий нативным EventSource и преобразующий его в транспортный порт Core. */
+export declare class BrowserSseStreamTransportFactory implements StreamTransportFactory {
+    private readonly _resolveAuthSession;
+    constructor(_resolveAuthSession: ResolveAuthSession);
+    open(artifact: Parameters<StreamTransportFactory['open']>[0], callbacks: Parameters<StreamTransportFactory['open']>[1]): StreamTransportConnection;
+}

package/dist/features/core/modules/source/EndgeSource_Module.d.ts

@@ -0,0 +1,59 @@
+import { SourceDocumentReference, SourceEngineCompileResult, SourceEngineGenerateResult, SourceEngineStrategy, SourceKind, SourceLanguageCompletion, SourceLanguageContext, SourceLanguageInlineHint, SourceLanguageSemanticHighlight, SourceLanguageSignatureHelp, SourceLanguageStrategy, SourceLanguageValidationResult, SourceParseResult, SourcePatchResult, SourcePatchStrategy } from './domain/types/source-engine.types';
+import { EndgeModule } from '../../../federation/EndgeModule';
+/** Модуль authoring-операций над source-документами Endge. */
+export declare class EndgeSource_Module extends EndgeModule {
+    private readonly _strategies;
+    private readonly _languageStrategies;
+    private readonly _patchStrategies;
+    /** Создаёт source-модуль и регистрирует встроенные strategies. */
+    constructor();
+    /** Регистрирует source strategy. Повторная регистрация с тем же id заменяет старую. */
+    registerStrategy(strategy: SourceEngineStrategy): void;
+    /** Регистрирует source language strategy. Повторная регистрация с тем же id заменяет старую. */
+    registerLanguageStrategy(strategy: SourceLanguageStrategy): void;
+    /** Регистрирует source patch strategy. Повторная регистрация с тем же id заменяет старую. */
+    registerPatchStrategy(strategy: SourcePatchStrategy): void;
+    /** Возвращает копию списка зарегистрированных source strategies. */
+    listStrategies(): SourceEngineStrategy[];
+    /** Возвращает копию списка зарегистрированных source language strategies. */
+    listLanguageStrategies(): SourceLanguageStrategy[];
+    /** Возвращает копию списка зарегистрированных source patch strategies. */
+    listPatchStrategies(): SourcePatchStrategy[];
+    /** Возвращает стратегию для указанного source-kind. */
+    resolveStrategy(sourceKind: SourceKind | string): SourceEngineStrategy | null;
+    /** Возвращает language strategy для указанного source-kind. */
+    resolveLanguageStrategy(sourceKind: SourceKind | string): SourceLanguageStrategy | null;
+    /** Возвращает patch strategy для указанного source-kind. */
+    resolvePatchStrategy(sourceKind: SourceKind | string): SourcePatchStrategy | null;
+    /** Генерирует source для указанного source-kind через зарегистрированную strategy. */
+    generate(sourceKind: SourceKind | string, model: unknown): SourceEngineGenerateResult;
+    /** Компилирует source указанного source-kind в normalized document и artifact payload. */
+    compile(sourceKind: SourceKind | string, source: string): SourceEngineCompileResult;
+    /** Парсит source указанного source-kind в normalized editor document. */
+    parse<TDocument = unknown>(sourceKind: SourceKind | string, source: string): SourceParseResult<TDocument>;
+    /** Патчит source указанного source-kind, сохраняя нетронутые участки авторского кода. */
+    patch<TPatch = unknown, TDocument = unknown>(sourceKind: SourceKind | string, source: string, patch: TPatch): SourcePatchResult<TDocument>;
+    /** Возвращает базовый source для новой сущности указанного source-kind. */
+    createDefault(sourceKind: SourceKind | string, variant?: string): string;
+    /** Нормализует source через language strategy без изменения semantic document. */
+    normalize(sourceKind: SourceKind | string, source: string): string;
+    /** Валидирует source указанного source-kind для editor-facing сценариев. */
+    validate(sourceKind: SourceKind | string, source: string, context?: Omit<SourceLanguageContext, 'source'>): SourceLanguageValidationResult;
+    /** Возвращает editor-facing completion items для указанного source-kind. */
+    completions(sourceKind: SourceKind | string, context: SourceLanguageContext): SourceLanguageCompletion[];
+    signatureHelp(sourceKind: SourceKind | string, context: SourceLanguageContext): SourceLanguageSignatureHelp | null;
+    /** Возвращает семантическую ссылку на внешний документ под курсором. */
+    referenceAt(sourceKind: SourceKind | string, context: SourceLanguageContext): SourceDocumentReference | null;
+    /** Возвращает renderer-neutral semantic highlights для source-документа. */
+    semanticHighlights(sourceKind: SourceKind | string, context: SourceLanguageContext): SourceLanguageSemanticHighlight[];
+    /** Возвращает renderer-neutral inline annotations для source-документа. */
+    inlineHints(sourceKind: SourceKind | string, context: SourceLanguageContext): SourceLanguageInlineHint[];
+    /** Регистрирует встроенные strategies ядра. */
+    private _registerDefaultStrategies;
+    /** Возвращает strategy или бросает явную ошибку для некорректного source-kind. */
+    private _resolveRequiredStrategy;
+    /** Возвращает language strategy или бросает явную ошибку для некорректного source-kind. */
+    private _resolveRequiredLanguageStrategy;
+    /** Возвращает patch strategy или бросает явную ошибку для некорректного source-kind. */
+    private _resolveRequiredPatchStrategy;
+}