@endge/core 4.0.3 → 6.0.0

package/dist/features/core/modules/source/services/strategies/DataViewSourceLanguageStrategy.d.ts

@@ -0,0 +1,17 @@
+import { SourceKind, SourceLanguageCompletion, SourceLanguageContext, SourceLanguageStrategy, SourceLanguageValidationResult } from '../../domain/types/source-engine.types';
+/** Source language strategy для editor-facing операций RDataView source. */
+export declare class DataViewSourceLanguageStrategy implements SourceLanguageStrategy {
+    readonly id = "source-language:data-view";
+    readonly sourceKind: SourceKind;
+    readonly syntax: import('../../domain/types/source-engine.types').SourceLanguageSyntaxDefinition;
+    /** Проверяет, что strategy обслуживает DataView source. */
+    supports(sourceKind: SourceKind | string): boolean;
+    /** Возвращает базовый source новой RDataView. */
+    createDefaultSource(): string;
+    /** Валидирует DataView source через текущий compiler pass. */
+    validate(source: string): SourceLanguageValidationResult;
+    /** Возвращает подсказки v1 для разрешенного DataView source API. */
+    completions(_context: SourceLanguageContext): SourceLanguageCompletion[];
+    resolveReference(context: SourceLanguageContext): import('../../domain/types/source-engine.types').SourceDocumentReference | null;
+    semanticHighlights(context: SourceLanguageContext): import('../../domain/types/source-engine.types').SourceLanguageSemanticHighlight[];
+}

package/dist/features/core/modules/source/services/strategies/FilterSourceEngineStrategy.d.ts

@@ -0,0 +1,8 @@
+import { SourceEngineCompileResult, SourceEngineStrategy, SourceKind } from '../../domain/types/source-engine.types';
+/** Source strategy для RFilter/source-kind=filter. */
+export declare class FilterSourceEngineStrategy implements SourceEngineStrategy {
+    readonly id = "source:filter";
+    readonly sourceKind: SourceKind;
+    supports(sourceKind: SourceKind | string): boolean;
+    compile(source: string): SourceEngineCompileResult;
+}

package/dist/features/core/modules/source/services/strategies/FilterSourceLanguageStrategy.d.ts

@@ -0,0 +1,12 @@
+import { SourceKind, SourceLanguageCompletion, SourceLanguageContext, SourceLanguageStrategy, SourceLanguageValidationResult } from '../../domain/types/source-engine.types';
+export declare class FilterSourceLanguageStrategy implements SourceLanguageStrategy {
+    readonly id = "source-language:filter";
+    readonly sourceKind: SourceKind;
+    readonly syntax: import('../../domain/types/source-engine.types').SourceLanguageSyntaxDefinition;
+    supports(sourceKind: SourceKind | string): boolean;
+    createDefaultSource(): string;
+    validate(source: string, context?: SourceLanguageContext): SourceLanguageValidationResult;
+    completions(context: SourceLanguageContext): SourceLanguageCompletion[];
+    resolveReference(context: SourceLanguageContext): import('../../domain/types/source-engine.types').SourceDocumentReference | null;
+    semanticHighlights(context: SourceLanguageContext): import('../../domain/types/source-engine.types').SourceLanguageSemanticHighlight[];
+}

package/dist/features/core/modules/source/services/strategies/FilterSourcePatchStrategy.d.ts

@@ -0,0 +1,10 @@
+import { FilterSourceEditorDocument, FilterSourcePatch } from '../../domain/types/filter-source.types';
+import { SourceKind, SourceParseResult, SourcePatchResult, SourcePatchStrategy } from '../../domain/types/source-engine.types';
+/** Source patch strategy для RFilter/source-kind=filter. */
+export declare class FilterSourcePatchStrategy implements SourcePatchStrategy<FilterSourcePatch, FilterSourceEditorDocument> {
+    readonly id = "source-patch:filter";
+    readonly sourceKind: SourceKind;
+    supports(sourceKind: SourceKind | string): boolean;
+    parse(source: string): SourceParseResult<FilterSourceEditorDocument>;
+    patch(source: string, patch: FilterSourcePatch): SourcePatchResult<FilterSourceEditorDocument>;
+}

package/dist/features/core/modules/source/services/strategies/QuerySourceEngineStrategy.d.ts

@@ -0,0 +1,12 @@
+import { SourceEngineCompileResult, SourceEngineOperation, SourceEngineResult, SourceEngineStrategy, SourceKind } from '../../domain/types/source-engine.types';
+/** Source strategy для RQuery/source-kind=query. */
+export declare class QuerySourceEngineStrategy implements SourceEngineStrategy {
+    readonly id = "source:query";
+    readonly sourceKind: SourceKind;
+    /** Проверяет, что стратегия обслуживает query source. */
+    supports(sourceKind: SourceKind | string): boolean;
+    /** Заглушка будущего analyze/patch API, чтобы strategy уже имела стабильный контракт. */
+    execute(_operation: SourceEngineOperation): SourceEngineResult;
+    /** Компилирует source-only Query v2 в canonical document и artifact payload. */
+    compile(source: string): SourceEngineCompileResult;
+}

package/dist/features/core/modules/source/services/strategies/QuerySourceLanguageStrategy.d.ts

@@ -0,0 +1,17 @@
+import { SourceKind, SourceLanguageCompletion, SourceLanguageContext, SourceLanguageStrategy, SourceLanguageSyntaxDefinition, SourceLanguageValidationResult } from '../../domain/types/source-engine.types';
+/** Source language strategy для editor-facing операций RQuery source. */
+export declare class QuerySourceLanguageStrategy implements SourceLanguageStrategy {
+    readonly id = "source-language:query";
+    readonly sourceKind: SourceKind;
+    readonly syntax: SourceLanguageSyntaxDefinition;
+    /** Проверяет, что стратегия обслуживает query source. */
+    supports(sourceKind: SourceKind | string): boolean;
+    /** Возвращает базовый source новой RQuery. */
+    createDefaultSource(variant?: string): string;
+    /** Валидирует query source через текущий compiler pass. */
+    validate(source: string, context?: SourceLanguageContext): SourceLanguageValidationResult;
+    /** Возвращает подсказки source-only Query v2 API. */
+    completions(context: SourceLanguageContext): SourceLanguageCompletion[];
+    resolveReference(context: SourceLanguageContext): import('../../domain/types/source-engine.types').SourceDocumentReference | null;
+    semanticHighlights(context: SourceLanguageContext): import('../../domain/types/source-engine.types').SourceLanguageSemanticHighlight[];
+}

package/dist/features/core/modules/source/services/strategies/QuerySourcePatchStrategy.d.ts

@@ -0,0 +1,13 @@
+import { QuerySourceDocument, QuerySourcePatch } from '../../domain/types/query-source.types';
+import { SourceKind, SourceParseResult, SourcePatchResult, SourcePatchStrategy } from '../../domain/types/source-engine.types';
+/** Source patch strategy для RQuery/source-kind=query. */
+export declare class QuerySourcePatchStrategy implements SourcePatchStrategy<QuerySourcePatch, QuerySourceDocument> {
+    readonly id = "source-patch:query";
+    readonly sourceKind: SourceKind;
+    /** Проверяет, что стратегия обслуживает query source. */
+    supports(sourceKind: SourceKind | string): boolean;
+    /** Парсит query source в normalized document для editor projections. */
+    parse(source: string): SourceParseResult<QuerySourceDocument>;
+    /** Патчит query source по editor-slot операции. */
+    patch(source: string, patch: QuerySourcePatch): SourcePatchResult<QuerySourceDocument>;
+}

package/dist/features/core/modules/source/services/strategies/StoreSourceEngineStrategy.d.ts

@@ -0,0 +1,7 @@
+import { SourceEngineCompileResult, SourceEngineStrategy, SourceKind } from '../../domain/types/source-engine.types';
+export declare class StoreSourceEngineStrategy implements SourceEngineStrategy {
+    readonly id = "source:store";
+    readonly sourceKind: SourceKind;
+    supports(sourceKind: SourceKind | string): boolean;
+    compile(source: string): SourceEngineCompileResult;
+}

package/dist/features/core/modules/source/services/strategies/StoreSourceLanguageStrategy.d.ts

@@ -0,0 +1,12 @@
+import { SourceKind, SourceLanguageCompletion, SourceLanguageContext, SourceLanguageStrategy, SourceLanguageValidationResult } from '../../domain/types/source-engine.types';
+export declare class StoreSourceLanguageStrategy implements SourceLanguageStrategy {
+    readonly id = "source-language:store";
+    readonly sourceKind: SourceKind;
+    readonly syntax: import('../../domain/types/source-engine.types').SourceLanguageSyntaxDefinition;
+    supports(sourceKind: SourceKind | string): boolean;
+    createDefaultSource(): string;
+    validate(source: string): SourceLanguageValidationResult;
+    completions(_context: SourceLanguageContext): SourceLanguageCompletion[];
+    resolveReference(context: SourceLanguageContext): import('../../domain/types/source-engine.types').SourceDocumentReference | null;
+    semanticHighlights(context: SourceLanguageContext): import('../../domain/types/source-engine.types').SourceLanguageSemanticHighlight[];
+}

package/dist/features/core/modules/source/services/strategies/StreamSourceEngineStrategy.d.ts

@@ -0,0 +1,7 @@
+import { SourceEngineCompileResult, SourceEngineStrategy, SourceKind } from '../../domain/types/source-engine.types';
+export declare class StreamSourceEngineStrategy implements SourceEngineStrategy {
+    readonly id = "source:stream";
+    readonly sourceKind: SourceKind;
+    supports(sourceKind: SourceKind | string): boolean;
+    compile(source: string): SourceEngineCompileResult;
+}

package/dist/features/core/modules/source/services/strategies/StreamSourceLanguageStrategy.d.ts

@@ -0,0 +1,10 @@
+import { SourceKind, SourceLanguageCompletion, SourceLanguageContext, SourceLanguageStrategy, SourceLanguageValidationResult } from '../../domain/types/source-engine.types';
+export declare class StreamSourceLanguageStrategy implements SourceLanguageStrategy {
+    readonly id = "source-language:stream";
+    readonly sourceKind: SourceKind;
+    readonly syntax: import('../../domain/types/source-engine.types').SourceLanguageSyntaxDefinition;
+    supports(sourceKind: SourceKind | string): boolean;
+    createDefaultSource(): string;
+    validate(source: string): SourceLanguageValidationResult;
+    completions(_context: SourceLanguageContext): SourceLanguageCompletion[];
+}

package/dist/features/core/modules/source/services/strategies/StyleSourceEngineStrategy.d.ts

@@ -0,0 +1,7 @@
+import { SourceEngineCompileResult, SourceEngineStrategy, SourceKind } from '../../domain/types/source-engine.types';
+export declare class StyleSourceEngineStrategy implements SourceEngineStrategy {
+    readonly id = "source:style";
+    readonly sourceKind: SourceKind;
+    supports(sourceKind: SourceKind | string): boolean;
+    compile(source: string): SourceEngineCompileResult;
+}

package/dist/features/core/modules/source/services/strategies/StyleSourceLanguageStrategy.d.ts

@@ -0,0 +1,43 @@
+import { SourceKind, SourceLanguageCompletion, SourceLanguageContext, SourceLanguageStrategy, SourceLanguageValidationResult } from '../../domain/types/source-engine.types';
+export declare class StyleSourceLanguageStrategy implements SourceLanguageStrategy {
+    readonly id = "source-language:style";
+    readonly sourceKind: SourceKind;
+    readonly syntax: {
+        aliases: string[];
+        extensions: string[];
+        comments: {
+            lineComment: string;
+            blockComment: [string, string];
+        };
+        brackets: Array<[string, string]>;
+        autoClosingPairs: {
+            open: string;
+            close: string;
+        }[];
+        triggerCharacters: string[];
+        tokenizer: {
+            root: ({
+                pattern: RegExp;
+                token: string;
+                next: string;
+            } | {
+                pattern: RegExp;
+                token: string;
+                next?: undefined;
+            })[];
+            comment: ({
+                pattern: RegExp;
+                token: string;
+                next?: undefined;
+            } | {
+                pattern: RegExp;
+                token: string;
+                next: string;
+            })[];
+        };
+    };
+    supports(sourceKind: SourceKind | string): boolean;
+    createDefaultSource(): string;
+    validate(source: string): SourceLanguageValidationResult;
+    completions(_context: SourceLanguageContext): SourceLanguageCompletion[];
+}

package/dist/features/core/modules/source/services/strategies/TypeSourceEngineStrategy.d.ts

@@ -0,0 +1,8 @@
+import { SourceEngineCompileResult, SourceEngineStrategy, SourceKind } from '../../domain/types/source-engine.types';
+/** Source strategy для RType/source-kind=type. */
+export declare class TypeSourceEngineStrategy implements SourceEngineStrategy {
+    readonly id = "source:type";
+    readonly sourceKind: SourceKind;
+    supports(sourceKind: SourceKind | string): boolean;
+    compile(source: string): SourceEngineCompileResult;
+}

package/dist/features/core/modules/source/services/strategies/TypeSourceLanguageStrategy.d.ts

@@ -0,0 +1,13 @@
+import { SourceKind, SourceLanguageCompletion, SourceLanguageContext, SourceLanguageStrategy, SourceLanguageValidationResult } from '../../domain/types/source-engine.types';
+export declare class TypeSourceLanguageStrategy implements SourceLanguageStrategy {
+    readonly id = "source-language:type";
+    readonly sourceKind: SourceKind;
+    readonly syntax: import('../../domain/types/source-engine.types').SourceLanguageSyntaxDefinition;
+    supports(sourceKind: SourceKind | string): boolean;
+    createDefaultSource(): string;
+    normalize(source: string): string;
+    validate(source: string, context?: SourceLanguageContext): SourceLanguageValidationResult;
+    completions(context: SourceLanguageContext): SourceLanguageCompletion[];
+    resolveReference(context: SourceLanguageContext): import('../../domain/types/source-engine.types').SourceDocumentReference | null;
+    semanticHighlights(context: SourceLanguageContext): import('../../domain/types/source-engine.types').SourceLanguageSemanticHighlight[];
+}

package/dist/features/core/modules/source/services/strategies/UpdateSourceEngineStrategy.d.ts

@@ -0,0 +1,7 @@
+import { SourceEngineCompileResult, SourceEngineStrategy, SourceKind } from '../../domain/types/source-engine.types';
+export declare class UpdateSourceEngineStrategy implements SourceEngineStrategy {
+    readonly id = "source:update";
+    readonly sourceKind: SourceKind;
+    supports(sourceKind: SourceKind | string): boolean;
+    compile(source: string): SourceEngineCompileResult;
+}

package/dist/features/core/modules/source/services/strategies/UpdateSourceLanguageStrategy.d.ts

@@ -0,0 +1,10 @@
+import { SourceKind, SourceLanguageCompletion, SourceLanguageContext, SourceLanguageStrategy, SourceLanguageValidationResult } from '../../domain/types/source-engine.types';
+export declare class UpdateSourceLanguageStrategy implements SourceLanguageStrategy {
+    readonly id = "source-language:update";
+    readonly sourceKind: SourceKind;
+    readonly syntax: import('../../domain/types/source-engine.types').SourceLanguageSyntaxDefinition;
+    supports(sourceKind: SourceKind | string): boolean;
+    createDefaultSource(): string;
+    validate(source: string): SourceLanguageValidationResult;
+    completions(_context: SourceLanguageContext): SourceLanguageCompletion[];
+}

package/dist/features/core/modules/source/services/strategies/VocabSourceEngineStrategy.d.ts

@@ -0,0 +1,8 @@
+import { SourceEngineCompileResult, SourceEngineOperation, SourceEngineResult, SourceEngineStrategy, SourceKind } from '../../domain/types/source-engine.types';
+export declare class VocabSourceEngineStrategy implements SourceEngineStrategy {
+    readonly id = "source:vocab";
+    readonly sourceKind: SourceKind;
+    supports(sourceKind: SourceKind | string): boolean;
+    execute(_operation: SourceEngineOperation): SourceEngineResult;
+    compile(source: string): SourceEngineCompileResult;
+}

package/dist/features/core/modules/source/services/strategies/VocabSourceLanguageStrategy.d.ts

@@ -0,0 +1,11 @@
+import { SourceKind, SourceLanguageCompletion, SourceLanguageContext, SourceLanguageStrategy, SourceLanguageValidationResult } from '../../domain/types/source-engine.types';
+export declare class VocabSourceLanguageStrategy implements SourceLanguageStrategy {
+    readonly id = "source-language:vocab";
+    readonly sourceKind: SourceKind;
+    readonly syntax: import('../../domain/types/source-engine.types').SourceLanguageSyntaxDefinition;
+    supports(sourceKind: SourceKind | string): boolean;
+    createDefaultSource(): string;
+    validate(source: string): SourceLanguageValidationResult;
+    completions(_context: SourceLanguageContext): SourceLanguageCompletion[];
+    resolveReference(context: SourceLanguageContext): import('../../domain/types/source-engine.types').SourceDocumentReference | null;
+}

package/dist/features/core/modules/source/services/strategies/VocabSourcePatchStrategy.d.ts

@@ -0,0 +1,9 @@
+import { SourceKind, SourceParseResult, SourcePatchResult, SourcePatchStrategy } from '../../domain/types/source-engine.types';
+import { VocabSourceDocument, VocabSourcePatch } from '../../domain/types/vocab-source.types';
+export declare class VocabSourcePatchStrategy implements SourcePatchStrategy<VocabSourcePatch, VocabSourceDocument> {
+    readonly id = "source-patch:vocab";
+    readonly sourceKind: SourceKind;
+    supports(sourceKind: SourceKind | string): boolean;
+    parse(source: string): SourceParseResult<VocabSourceDocument>;
+    patch(source: string, patch: VocabSourcePatch): SourcePatchResult<VocabSourceDocument>;
+}

package/dist/features/core/modules/source/services/type-source-references.d.ts

@@ -0,0 +1,14 @@
+import { SourceDocumentReference, SourceLanguageContext } from '../domain/types/source-engine.types';
+interface TypeSourceReferenceLocation extends SourceDocumentReference {
+    normalizationRange: SourceDocumentReference['range'];
+}
+/** Собирает ссылки на Type Registry из поддержанных Type Source выражений. */
+export declare function collectTypeSourceReferences(source: string): TypeSourceReferenceLocation[];
+/** Собирает ссылки Type Registry из вызовов value(Type, ...) в Configuration Source. */
+export declare function collectConfigurationTypeSourceReferences(source: string): TypeSourceReferenceLocation[];
+/** Переводит ссылки на типы в канонический синтаксис без кавычек. */
+export declare function normalizeTypeSourceReferences(source: string): string;
+/** Находит ссылку Type Source в позиции редактора. */
+export declare function resolveTypeSourceReference(context: SourceLanguageContext): SourceDocumentReference | null;
+export declare function resolveConfigurationTypeSourceReference(context: SourceLanguageContext): SourceDocumentReference | null;
+export {};

package/dist/features/core/modules/source/services/type-source-serialize.d.ts

@@ -0,0 +1,6 @@
+import { TypeSourceDocument, TypeSourceExpression } from '../domain/types/type-source.types';
+/** Детерминированный сериализатор канонических документов Type Source v1. */
+export declare function serializeTypeSourceDocument(document: TypeSourceDocument): string;
+export declare function serializeTypeSourceExpression(expression: TypeSourceExpression, indent?: number): string;
+/** Сериализует одну именованную ссылку на тип в каноническом кратком синтаксисе, когда это возможно. */
+export declare function serializeTypeSourceReference(identity: string): string;

package/dist/features/core/modules/source/services/typescript-type-source.d.ts

@@ -0,0 +1,18 @@
+import { TypeSourceDocument } from '../domain/types/type-source.types';
+export interface TypeScriptTypeDeclarationRange {
+    start: number;
+    end: number;
+}
+/** Анализ одного объявления типа TypeScript верхнего уровня для редактора. */
+export interface TypeScriptTypeDeclarationAnalysis {
+    kind: 'interface' | 'type';
+    identity: string;
+    range: TypeScriptTypeDeclarationRange;
+    actionAnchor: number;
+    source: string;
+    document: TypeSourceDocument | null;
+    dependencies: string[];
+    unsupportedReason: string | null;
+}
+/** Разбирает объявления `interface` и `type` верхнего уровня из одного script-блока TS. */
+export declare function analyzeTypeScriptTypeDeclarations(source: string): TypeScriptTypeDeclarationAnalysis[];

package/dist/features/core/modules/source/services/value-expression-language.d.ts

@@ -0,0 +1,5 @@
+import { SourceLanguageCompletion } from '../domain/types/source-engine.types';
+/** Общий vocabulary ValueExpression, подключаемый всеми domain source languages. */
+export declare const VALUE_EXPRESSION_FUNCTION_NAMES: string[];
+export declare const VALUE_EXPRESSION_METHOD_NAMES: string[];
+export declare const VALUE_EXPRESSION_COMPLETIONS: SourceLanguageCompletion[];

package/dist/features/core/modules/source/services/value-expression-operations.d.ts

@@ -0,0 +1,10 @@
+import { SourceExpressionIR, SourceExpressionOperation, SourceExpressionWarning } from '../domain/types/source-expression.types';
+export interface ValueOperationRuntime {
+    evaluate: (expression: SourceExpressionIR, current?: unknown) => unknown;
+    memoize: <T>(owner: object, key: string, create: () => T) => T;
+    warn: (warning: SourceExpressionWarning) => void;
+}
+export type ValueOperation = (args: SourceExpressionIR[], runtime: ValueOperationRuntime) => unknown;
+/** Единственный runtime-registry операций для Query, Composition и DataView. */
+export declare const VALUE_EXPRESSION_OPERATIONS: Record<SourceExpressionOperation, ValueOperation>;
+export declare function readPath(source: unknown, path: string): unknown;

package/dist/features/core/modules/source/services/vocab-source-patch.d.ts

@@ -0,0 +1,10 @@
+import { SourcePatchResult } from '../domain/types/source-engine.types';
+import { VocabSourceDocument, VocabSourcePatch } from '../domain/types/vocab-source.types';
+export declare function parseVocabSource(source: string): {
+    ok: boolean;
+    ast: {} | undefined;
+    document: VocabSourceDocument | undefined;
+    diagnostics: Omit<import('../../program/domain/types/program.types').ProgramDiagnostic, "entityRef">[];
+    message: string | undefined;
+};
+export declare function patchVocabSource(source: string, patch: VocabSourcePatch): SourcePatchResult<VocabSourceDocument>;

package/dist/features/core/modules/source/templates/configuration.default.source.d.ts

@@ -0,0 +1,2 @@
+/** Базовый source новой категории Configuration v1. */
+export declare const CONFIGURATION_DEFAULT_SOURCE = "defineConfig({})\n";

package/dist/features/core/modules/styles/EndgeStyles_Module.d.ts

@@ -0,0 +1,26 @@
+import { AcquireEndgeStyleOptions, EndgeStyleLease, EndgeStyleMatchNode, EndgeStylePlacement, EndgeStyleResolvedDeclaration, EndgeStyleSheetArtifact, EndgeStyleTargetProfile } from './domain/types/style.types';
+import { EndgeModule } from '../../../federation/EndgeModule';
+export interface EndgeStyleResolver {
+    readonly target: EndgeStyleTargetProfile;
+    resolve: (node: EndgeStyleMatchNode, theme?: string) => Record<string, EndgeStyleResolvedDeclaration>;
+}
+/** Нейтральный реестр стилей. Материализаторы renderer используют его артефакты и resolver. */
+export declare class EndgeStyles_Module extends EndgeModule {
+    private _unsubscribeProgram;
+    private readonly _placements;
+    private _leaseSequence;
+    private _transactionDepth;
+    private _notificationPending;
+    start(): void;
+    /** Возвращает валидные скомпилированные артефакты. Наличие не активирует стиль. */
+    getAvailableArtifacts(): EndgeStyleSheetArtifact[];
+    /** Возвращает только размещения, полученные активными владельцами runtime. */
+    getActivePlacements(): EndgeStylePlacement[];
+    getActiveArtifacts(): EndgeStyleSheetArtifact[];
+    acquireStyle(options: AcquireEndgeStyleOptions): EndgeStyleLease;
+    transaction<T>(operation: () => T): T;
+    /** Создаёт независимый от renderer resolver поверх активного snapshot программы. */
+    createResolver(target: EndgeStyleTargetProfile): EndgeStyleResolver;
+    reset(): void;
+    private _changed;
+}

package/dist/features/core/modules/styles/domain/types/style.types.d.ts

@@ -0,0 +1,202 @@
+export interface EndgeStyleSourceRange {
+    start: number;
+    end: number;
+    line: number;
+    column: number;
+}
+export interface EndgeStyleDiagnostic {
+    severity: 'info' | 'warning' | 'error';
+    code: string;
+    message: string;
+    range?: EndgeStyleSourceRange;
+}
+export interface EndgeStyleSpecificity {
+    ids: number;
+    classes: number;
+    types: number;
+}
+export type EndgeStyleCombinator = 'descendant' | 'child' | 'adjacent' | 'sibling';
+export type EndgeStyleAttributeOperator = 'exists' | '=' | '~=' | '|=' | '^=' | '$=' | '*=';
+export interface EndgeStyleAttributeSelector {
+    name: string;
+    operator: EndgeStyleAttributeOperator;
+    value?: string;
+    insensitive?: boolean;
+}
+export type EndgeStylePseudoSelector = {
+    name: 'first-child' | 'last-child';
+} | {
+    name: 'nth-child';
+    expression: string;
+} | {
+    name: 'component' | 'identity' | 'state';
+    value: string;
+} | {
+    name: 'not' | 'is' | 'where';
+    selectors: EndgeStyleSelector[];
+} | {
+    name: 'part';
+    value: string;
+    element: true;
+};
+export interface EndgeStyleCompoundSelector {
+    tag?: string;
+    universal?: boolean;
+    ids: string[];
+    classes: string[];
+    attributes: EndgeStyleAttributeSelector[];
+    pseudos: EndgeStylePseudoSelector[];
+}
+export interface EndgeStyleSelectorSegment {
+    combinator: EndgeStyleCombinator | null;
+    compound: EndgeStyleCompoundSelector;
+}
+/** Селектор хранится слева направо, а matcher вычисляет его справа налево. */
+export interface EndgeStyleSelector {
+    source: string;
+    segments: EndgeStyleSelectorSegment[];
+    specificity: EndgeStyleSpecificity;
+}
+export interface EndgeStyleValueToken {
+    type: 'word' | 'string' | 'space' | 'divider' | 'function' | 'comment';
+    value: string;
+    nodes?: EndgeStyleValueToken[];
+}
+export interface EndgeStyleDeclaration {
+    property: string;
+    value: string;
+    valueTokens: EndgeStyleValueToken[];
+    important: boolean;
+    range?: EndgeStyleSourceRange;
+}
+export type EndgeStyleSupportCondition = {
+    type: 'renderer';
+    renderer: string;
+} | {
+    type: 'capability';
+    capability: string;
+} | {
+    type: 'not';
+    operand: EndgeStyleSupportCondition;
+} | {
+    type: 'and' | 'or';
+    operands: EndgeStyleSupportCondition[];
+};
+export interface EndgeStyleScope {
+    root: EndgeStyleSelector[];
+    limit?: EndgeStyleSelector[];
+}
+export interface EndgeStyleRule {
+    id: string;
+    selectors: EndgeStyleSelector[];
+    declarations: EndgeStyleDeclaration[];
+    theme?: string;
+    scope?: EndgeStyleScope;
+    supports?: EndgeStyleSupportCondition;
+    sourceOrder: number;
+    range?: EndgeStyleSourceRange;
+}
+export interface EndgeStyleTheme {
+    id: string;
+    declarations: EndgeStyleDeclaration[];
+    range?: EndgeStyleSourceRange;
+}
+export interface EndgeStyleRuleIndex {
+    universal: string[];
+    tags: Record<string, string[]>;
+    classes: Record<string, string[]>;
+    ids: Record<string, string[]>;
+    components: Record<string, string[]>;
+    identities: Record<string, string[]>;
+    states: Record<string, string[]>;
+    parts: Record<string, string[]>;
+}
+export interface EndgeStyleSheetArtifact {
+    language: 'endgecss';
+    version: 1;
+    identity: string;
+    sourceHash: string;
+    scope: 'global' | 'component';
+    scopeId?: string;
+    rules: EndgeStyleRule[];
+    themes: EndgeStyleTheme[];
+    indexes: EndgeStyleRuleIndex;
+}
+export interface EndgeStyleAst {
+    type: 'stylesheet';
+    source: string;
+    nodes: unknown[];
+}
+export interface CompileEndgeCSSOptions {
+    identity?: string;
+    scope?: 'global' | 'component';
+    scopeId?: string;
+    maxNestedSelectors?: number;
+}
+export interface CompileEndgeCSSResult {
+    ast: EndgeStyleAst | null;
+    artifact: EndgeStyleSheetArtifact | null;
+    diagnostics: EndgeStyleDiagnostic[];
+}
+export interface EndgeStyleTargetProfile {
+    renderer: string;
+    capabilities?: Iterable<string>;
+}
+/** Нейтральный к renderer логический узел. DOM-обёртки намеренно отсутствуют. */
+export interface EndgeStyleMatchNode {
+    tag: string;
+    id?: string;
+    classes: ReadonlySet<string>;
+    attributes: Readonly<Record<string, unknown>>;
+    states: ReadonlySet<string>;
+    parts: ReadonlySet<string>;
+    component?: string;
+    identity?: string;
+    ownerScopeId?: string;
+    /** Иерархия lifecycle runtime для нейтральной к renderer изоляции размещения. */
+    runtimeScopeIds?: ReadonlySet<string>;
+    parent?: EndgeStyleMatchNode;
+    /**
+     * Непосредственный логический предшественник. Связанная цепочка сохраняет соседние
+     * комбинаторы нейтральными к renderer без копии префикса в каждом узле.
+     */
+    previousSibling?: EndgeStyleMatchNode;
+    index: number;
+    siblingCount: number;
+}
+export interface EndgeStyleResolvedDeclaration extends EndgeStyleDeclaration {
+    ruleId: string;
+    specificity: EndgeStyleSpecificity;
+    sourceOrder: number;
+}
+export interface EndgeStylePlacement {
+    id: string;
+    artifactIdentity: string;
+    artifact: EndgeStyleSheetArtifact;
+    ownerScopeIds: readonly string[];
+    boundaryId: string;
+    orderKey: string;
+    state: 'active' | 'suspended';
+    referenceCount: number;
+}
+export interface AcquireEndgeStyleOptions {
+    artifactIdentity?: string;
+    artifact?: EndgeStyleSheetArtifact;
+    ownerScopeId: string;
+    boundaryId: string;
+    orderKey?: string;
+}
+export interface EndgeStyleLease {
+    readonly id: string;
+    readonly kind: 'style';
+    readonly artifactIdentity: string;
+    readonly ownerScopeId: string;
+    readonly boundaryId: string;
+    readonly orderKey: string;
+    readonly suspended: boolean;
+    suspend: () => void;
+    resume: () => void;
+    release: () => void;
+    pause: () => void;
+    dispose: () => void;
+}

package/dist/features/core/modules/styles/services/endgecss-compile.d.ts

@@ -0,0 +1,4 @@
+import { CompileEndgeCSSOptions, CompileEndgeCSSResult, EndgeStyleSelector, EndgeStyleSupportCondition } from '../domain/types/style.types';
+export declare function parseEndgeStyleSelectorList(source: string): EndgeStyleSelector[];
+export declare function parseEndgeStyleSupportCondition(source: string): EndgeStyleSupportCondition;
+export declare function compileEndgeCSS(source: string, options?: CompileEndgeCSSOptions): CompileEndgeCSSResult;

package/dist/features/core/modules/styles/services/endgecss-match.d.ts

@@ -0,0 +1,5 @@
+import { EndgeStyleMatchNode, EndgeStyleResolvedDeclaration, EndgeStyleRule, EndgeStyleSelector, EndgeStyleSheetArtifact, EndgeStyleSupportCondition, EndgeStyleTargetProfile } from '../domain/types/style.types';
+export declare function matchEndgeStyleSelector(selector: EndgeStyleSelector, node: EndgeStyleMatchNode): boolean;
+export declare function evaluateEndgeStyleSupport(condition: EndgeStyleSupportCondition | undefined, target: EndgeStyleTargetProfile): boolean;
+export declare function matchEndgeStyleRule(artifact: EndgeStyleSheetArtifact, rule: EndgeStyleRule, node: EndgeStyleMatchNode, target: EndgeStyleTargetProfile, theme?: string): EndgeStyleSelector[];
+export declare function resolveEndgeStyleDeclarations(artifacts: readonly EndgeStyleSheetArtifact[], node: EndgeStyleMatchNode, target: EndgeStyleTargetProfile, theme?: string): Record<string, EndgeStyleResolvedDeclaration>;