@endge/core 1.2.5 → 1.2.8

package/dist/domain/types/component/sfc/visual-projection.types.d.ts

@@ -0,0 +1,140 @@
+import { RComponentDiagnostic } from '../component-core.types';
+import { TypeSourceDefinition } from '../../source/type-source.types';
+import { RComponentSFC_IR_Tag } from './ir.types';
+import { RComponentSFC_SourceRange } from './location.types';
+/** Значение SFC source, подготовленное для безопасного отображения в visual editor. */
+export type ComponentSFCVisualSourceValue = {
+    kind: 'boolean';
+    value: boolean;
+} | {
+    kind: 'literal';
+    value: unknown;
+} | {
+    kind: 'expression';
+    source: string;
+};
+/** Один attribute исходного SFC-узла без привязки к конкретному UI framework. */
+export interface ComponentSFCVisualAttribute {
+    name: string;
+    value: ComponentSFCVisualSourceValue;
+    sourceRange?: RComponentSFC_SourceRange;
+}
+/** Редактируемый prop binding единственного управляемого элемента колонки Table. */
+export type ComponentSFCTableCellBindingProjection = ComponentSFCVisualAttribute;
+/** Способ, которым содержимое ячейки представлено в простом visual editor. */
+export type ComponentSFCTableVisualCellTag = Exclude<RComponentSFC_IR_Tag, 'Component' | 'Table' | 'Column' | 'Cell' | 'ColumnMenu' | 'MenuItem' | 'MenuSeparator'>;
+export type ComponentSFCTableCellProjection = {
+    kind: 'default';
+} | {
+    kind: 'component';
+    identity: string | null;
+    syntax: 'cell' | 'direct';
+    bindings: ComponentSFCTableCellBindingProjection[];
+} | {
+    kind: 'tag';
+    tag: ComponentSFCTableVisualCellTag;
+    syntax: 'cell' | 'direct';
+    bindings: ComponentSFCTableCellBindingProjection[];
+} | {
+    kind: 'source';
+};
+/** Registry context required to resolve direct user component tags while reading Source. */
+export interface ComponentSFCVisualInspectionOptions {
+    resolveComponentTag?: (tag: string) => string | null;
+    resolveTypeDefinition?: (identity: string) => TypeSourceDefinition | null;
+}
+/** Visual read-model одной прямой Column внутри корневого Table. */
+export interface ComponentSFCTableColumnProjection {
+    id: string;
+    index: number;
+    key: ComponentSFCVisualSourceValue | null;
+    title: ComponentSFCVisualSourceValue | null;
+    width: ComponentSFCVisualSourceValue | null;
+    sortable: ComponentSFCVisualSourceValue | null;
+    sort: ComponentSFCVisualSourceValue | null;
+    sortBy: ComponentSFCVisualSourceValue | null;
+    pinnable: ComponentSFCVisualSourceValue | null;
+    attributes: ComponentSFCVisualAttribute[];
+    cell: ComponentSFCTableCellProjection;
+    hasCustomCell: boolean;
+    cellSource: string | null;
+    sourceRange: RComponentSFC_SourceRange;
+}
+/** Минимальные source-preserving операции visual editor таблицы. */
+export type ComponentSFCTableSourcePatch = {
+    type: 'add-column';
+    title?: string;
+    key?: string;
+} | {
+    type: 'remove-column';
+    columnIndex: number;
+} | {
+    type: 'move-column';
+    fromIndex: number;
+    toIndex: number;
+} | {
+    type: 'set-column-attribute';
+    columnIndex: number;
+    name: 'key' | 'title' | 'width' | 'sortable' | 'sort' | 'sort-by';
+    value: string | null;
+} | {
+    type: 'set-table-attribute';
+    name: 'ref' | 'selection-mode' | 'paging' | 'page-size' | 'page-sizes' | 'default-pin' | 'default-sort' | 'default-hidden';
+    value: string | null;
+} | {
+    type: 'set-column-component';
+    columnIndex: number;
+    identity: string | null;
+    syntax?: 'cell' | 'direct';
+} | {
+    type: 'set-column-tag';
+    columnIndex: number;
+    tag: ComponentSFCTableVisualCellTag | null;
+    syntax?: 'cell' | 'direct';
+} | {
+    type: 'set-column-cell-attribute';
+    columnIndex: number;
+    name: string;
+    value: string | null;
+    valueKind: 'expression' | 'literal';
+};
+/** Результат точечного изменения SFC Table source. */
+export interface ComponentSFCTableSourcePatchResult {
+    ok: boolean;
+    source: string;
+    changed: boolean;
+    projection: ComponentSFCTableVisualProjection | null;
+    diagnostics: RComponentDiagnostic[];
+    message?: string;
+}
+/** Visual read-model SFC, template которого содержит один корневой Table. */
+export interface ComponentSFCTableVisualProjection {
+    kind: 'table';
+    ref: ComponentSFCVisualSourceValue | null;
+    selectionMode: ComponentSFCVisualSourceValue | null;
+    rows: ComponentSFCVisualSourceValue | null;
+    rowKey: ComponentSFCVisualSourceValue | null;
+    paging: ComponentSFCVisualSourceValue | null;
+    pageSize: ComponentSFCVisualSourceValue | null;
+    pageSizes: ComponentSFCVisualSourceValue | null;
+    sortMode: ComponentSFCVisualSourceValue | null;
+    defaultSort: ComponentSFCVisualSourceValue | null;
+    columnPin: ComponentSFCVisualSourceValue | null;
+    defaultPin: ComponentSFCVisualSourceValue | null;
+    defaultHidden: ComponentSFCVisualSourceValue | null;
+    columnMenu: ComponentSFCVisualSourceValue | null;
+    attributes: ComponentSFCVisualAttribute[];
+    columns: ComponentSFCTableColumnProjection[];
+    sourceRange: RComponentSFC_SourceRange;
+}
+/** Результат выбора специализированного visual editor для SFC source. */
+export interface ComponentSFCVisualInspection {
+    support: {
+        kind: 'table';
+    } | {
+        kind: 'none';
+        reason: 'source-empty' | 'template-missing' | 'root-count' | 'root-not-table';
+    };
+    projection: ComponentSFCTableVisualProjection | null;
+    diagnostics: RComponentDiagnostic[];
+}

package/dist/domain/types/computation/computation-program.types.d.ts

@@ -0,0 +1,36 @@
+import { SourceExpressionIR } from '../source/source-expression.types';
+import { ComputationSourceDocument } from './computation-source.types';
+/** Optional persisted metadata; v1 compiler does not compare contracts. */
+export interface ComputationContractField {
+    type: string;
+    isArray?: boolean;
+    optional?: boolean;
+}
+export type ComputationProgramNode = {
+    kind: 'expression';
+    name: string;
+    dependencies: string[];
+    expression: SourceExpressionIR;
+} | {
+    kind: 'typescript';
+    name: string;
+    dependencies: string[];
+    inputs: Record<string, SourceExpressionIR>;
+    moduleKey: string;
+    source: string;
+} | {
+    kind: 'computation';
+    name: string;
+    dependencies: string[];
+    identity: string;
+    input: SourceExpressionIR;
+};
+/** Runtime-ready graph compiled from one defineComputation source document. */
+export interface ComputationProgramPayload {
+    input: ComputationContractField | null;
+    output: ComputationContractField | null;
+    sourceDocument: ComputationSourceDocument | null;
+    nodes: ComputationProgramNode[];
+    result: SourceExpressionIR | null;
+    execution: 'sync' | 'async';
+}

package/dist/domain/types/computation/computation-runtime.types.d.ts

@@ -0,0 +1,48 @@
+import { SourceExpressionIR } from '../source/source-expression.types';
+export type ComputationResourceStatus = 'idle' | 'pending' | 'success' | 'error';
+export interface ComputationRuntimeErrorShape {
+    name: 'ComputationRuntimeError';
+    message: string;
+    computationIdentity: string;
+    outputName?: string;
+    kind: string;
+}
+export interface ComputationResource<T = unknown> {
+    readonly status: ComputationResourceStatus;
+    readonly loading: boolean;
+    readonly value: T | undefined;
+    readonly error: ComputationRuntimeErrorShape | null;
+    refresh(): Promise<void>;
+    subscribe(listener: VoidFunction): VoidFunction;
+    dispose(): void;
+}
+export interface ComputationSandboxRequest {
+    computationIdentity: string;
+    outputName: string;
+    moduleKey: string;
+    source: string;
+    inputs: Record<string, unknown>;
+}
+export interface ComputationSandboxAdapter {
+    execute(request: ComputationSandboxRequest): Promise<unknown>;
+    dispose?(): void | Promise<void>;
+}
+/** Shared execution scope одного root computation call. */
+export interface ComputationExecutionScope {
+    readonly stack: readonly string[];
+    readonly budget: {
+        calls: number;
+    };
+}
+/** Runtime boundary для вызова compiler-linked computation dependency. */
+export interface ComputationDependencyRunner {
+    run(identity: string, input: unknown, scope: ComputationExecutionScope): Promise<unknown>;
+    runSync(identity: string, input: unknown, scope: ComputationExecutionScope): unknown;
+}
+export interface ComputationExecutionApi {
+    evaluate(expression: SourceExpressionIR, scope?: unknown): unknown;
+}
+export interface ComputationOverride {
+    execution: 'sync' | 'async';
+    run(input: unknown, api: ComputationExecutionApi): unknown | Promise<unknown>;
+}

package/dist/domain/types/computation/computation-source.types.d.ts

@@ -0,0 +1,28 @@
+import { SourceExpressionIR } from '../source/source-expression.types';
+export interface ComputationSourceRange {
+    start: number;
+    end: number;
+}
+export type ComputationSourceNode = {
+    kind: 'expression';
+    name: string;
+    expression: SourceExpressionIR;
+    sourceRange?: ComputationSourceRange;
+} | {
+    kind: 'typescript';
+    name: string;
+    inputs: Record<string, SourceExpressionIR>;
+    source: string;
+    sourceRange?: ComputationSourceRange;
+} | {
+    kind: 'computation';
+    name: string;
+    identity: string;
+    input: SourceExpressionIR;
+    sourceRange?: ComputationSourceRange;
+};
+/** Canonical compiler-derived representation of defineComputation source. */
+export interface ComputationSourceDocument {
+    outputs: ComputationSourceNode[];
+    result: SourceExpressionIR;
+}

package/dist/domain/types/computation/computation.types.d.ts

@@ -0,0 +1,3 @@
+export * from './computation-program.types';
+export * from './computation-runtime.types';
+export * from './computation-source.types';

package/dist/domain/types/computation/index.d.ts

@@ -0,0 +1 @@
+export * from './computation.types';

package/dist/domain/types/configuration/configuration.type.d.ts

@@ -0,0 +1,127 @@
+import { DiagnosticsSeverityNumber, DiagnosticsSignal, EndgeDiagnosticsOutputConfiguration, EndgeDiagnosticsConfiguration, EndgeDiagnosticsRoute } from '../diagnostics';
+export interface EndgeLocaleDefinition {
+    code: string;
+    displayName: string;
+    shortLabel: string;
+    direction?: 'ltr' | 'rtl';
+}
+export interface EndgeThemeDefinition {
+    identity: string;
+    displayName: string;
+}
+export type EndgeSSEAuthMode = 'inherit' | 'profile' | 'manual' | 'none';
+export interface EndgeVariableDefinition {
+    name: string;
+    defaultValue: string;
+}
+export interface EndgeSSEConfiguration {
+    url: string;
+    authMode?: EndgeSSEAuthMode;
+    authProfileIdentity?: string | null;
+    manualToken?: string | null;
+}
+/** Полная конфигурация, с которой компилируется один Endge context. */
+export interface EndgeConfiguration {
+    vars: EndgeVariableDefinition[];
+    sse?: EndgeSSEConfiguration;
+    locales: EndgeLocaleDefinition[];
+    defaultLocale: string;
+    fallbackLocale: string;
+    themes: EndgeThemeDefinition[];
+    defaultTheme: string;
+    defaultAuthProfileIdentity: string | null;
+    sfcAdapterIds: string[];
+    defaultSfcAdapterId: string;
+    /** Настройки telemetry, output adapters, routing и snapshots. */
+    diagnostics: EndgeDiagnosticsConfiguration;
+}
+export type EndgeValueOverride<T> = {
+    op: 'set';
+    value: T;
+} | {
+    op: 'remove';
+};
+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>;
+    sse?: EndgeValueOverride<EndgeSSEConfiguration>;
+    locales?: EndgeCollectionPatch<EndgeLocaleDefinition>;
+    defaultLocale?: EndgeValueOverride<string>;
+    fallbackLocale?: EndgeValueOverride<string>;
+    themes?: EndgeCollectionPatch<EndgeThemeDefinition>;
+    defaultTheme?: EndgeValueOverride<string>;
+    defaultAuthProfileIdentity?: EndgeValueOverride<string>;
+    sfcAdapterIds?: EndgeCollectionPatch<string>;
+    defaultSfcAdapterId?: EndgeValueOverride<string>;
+    /** Локальный contribution diagnostics для текущего configuration layer. */
+    diagnostics?: EndgeDiagnosticsConfigurationPatch;
+}
+/** Patch локальной collection policy модуля диагностики. */
+export interface EndgeDiagnosticsCollectionPatch {
+    enabled?: EndgeValueOverride<boolean>;
+    signals?: EndgeCollectionPatch<DiagnosticsSignal>;
+    minSeverity?: EndgeValueOverride<DiagnosticsSeverityNumber>;
+    maxRecords?: EndgeValueOverride<number>;
+}
+/** Patch telemetry configuration с merge outputs и routes по стабильному id. */
+export interface EndgeDiagnosticsTelemetryPatch {
+    collection?: EndgeDiagnosticsCollectionPatch;
+    outputs?: EndgeCollectionPatch<EndgeDiagnosticsOutputConfiguration>;
+    routes?: EndgeCollectionPatch<EndgeDiagnosticsRoute>;
+}
+/** Patch состава диагностического snapshot. */
+export interface EndgeDiagnosticsSnapshotContentPatch {
+    telemetry?: EndgeValueOverride<boolean>;
+    problems?: EndgeValueOverride<boolean>;
+    configuration?: EndgeValueOverride<boolean>;
+}
+/** Patch условий автоматического snapshot. */
+export interface EndgeDiagnosticsAutomaticSnapshotPatch {
+    enabled?: EndgeValueOverride<boolean>;
+    errorCount?: EndgeValueOverride<number>;
+    windowSeconds?: EndgeValueOverride<number>;
+    cooldownSeconds?: EndgeValueOverride<number>;
+    outputIds?: EndgeCollectionPatch<string>;
+}
+/** Patch snapshots configuration текущего cascade layer. */
+export interface EndgeDiagnosticsSnapshotsPatch {
+    content?: EndgeDiagnosticsSnapshotContentPatch;
+    automatic?: EndgeDiagnosticsAutomaticSnapshotPatch;
+}
+/** Patch diagnostics configuration текущего cascade layer. */
+export interface EndgeDiagnosticsConfigurationPatch {
+    telemetry?: EndgeDiagnosticsTelemetryPatch;
+    snapshots?: EndgeDiagnosticsSnapshotsPatch;
+}
+export type EndgeConfigurationContribution = {
+    mode: 'inherit';
+    patch: EndgeConfigurationPatch;
+} | {
+    mode: 'replace';
+    value: EndgeConfiguration;
+};
+export type EndgeConfigurationLayer = 'workspace' | 'tenant' | 'project' | 'environment';
+/** Structural context одного полного boot/build lifecycle. */
+export interface EndgeExecutionContext {
+    tenantIdentity: string;
+    projectIdentity: string;
+    environmentIdentity: string;
+}
+/** Immutable input, передаваемый compiler strategies. */
+export interface EndgeBuildContext {
+    workspaceIdentity: string;
+    execution: EndgeExecutionContext;
+    configuration: EndgeConfiguration;
+    contextHash: string;
+}

package/dist/domain/types/configuration/index.d.ts

@@ -0,0 +1 @@
+export * from './configuration.type';

package/dist/domain/types/diagnostics/diagnostics-adapter.type.d.ts

@@ -0,0 +1,53 @@
+import { DiagnosticsRecord, DiagnosticsResource, DiagnosticsSnapshot, EndgeDiagnosticsOutputConfiguration } from './diagnostics.types';
+/** Возможности, которые конкретный тип diagnostics adapter предоставляет ядру. */
+export interface DiagnosticsAdapterCapabilities {
+    records: boolean;
+    snapshots: boolean;
+    test: boolean;
+}
+/** Контекст создания runtime adapter для одного настроенного канала вывода. */
+export interface DiagnosticsAdapterCreateContext {
+    sessionId: string;
+    resource: DiagnosticsResource;
+    /** Разрешает persisted variable token без сохранения полученного секрета в configuration. */
+    resolveVariable?: (value: string) => string | undefined;
+}
+/** Контекст доставки одной записи после применения route. */
+export interface DiagnosticsAdapterRecordContext extends DiagnosticsAdapterCreateContext {
+    routeIds: string[];
+    output: EndgeDiagnosticsOutputConfiguration;
+}
+/** Контекст доставки диагностического снимка. */
+export interface DiagnosticsAdapterSnapshotContext extends DiagnosticsAdapterCreateContext {
+    output: EndgeDiagnosticsOutputConfiguration;
+    trigger: DiagnosticsSnapshot['trigger'];
+}
+/** Runtime adapter, созданный для одного output из effective configuration. */
+export interface DiagnosticsAdapter {
+    readonly id: string;
+    /** Принимает record, прошедший маршрутизацию в текущий output. */
+    acceptRecord(record: DiagnosticsRecord, context: DiagnosticsAdapterRecordContext): void | Promise<void>;
+    /** Принимает полный JSON-safe snapshot, если adapter поддерживает snapshots. */
+    acceptSnapshot?(snapshot: DiagnosticsSnapshot, context: DiagnosticsAdapterSnapshotContext): void | Promise<void>;
+    /** Проверяет доступность output без изменения diagnostics history. */
+    test?(): void | Promise<void>;
+    /** Доставляет накопленный adapter buffer без завершения session. */
+    flush?(): void | Promise<void>;
+    /** Освобождает внешние ресурсы adapter при пересборке или reset. */
+    dispose?(): void | Promise<void>;
+}
+/** Фабрика одного расширяемого типа diagnostics adapter. */
+export interface DiagnosticsAdapterFactory {
+    readonly type: string;
+    readonly capabilities: DiagnosticsAdapterCapabilities;
+    /** Создаёт runtime adapter для конкретного output из effective configuration. */
+    create(output: EndgeDiagnosticsOutputConfiguration, context: DiagnosticsAdapterCreateContext): DiagnosticsAdapter;
+}
+/** Результат best-effort flush всех активных output adapters. */
+export interface DiagnosticsFlushResult {
+    succeeded: string[];
+    failed: Array<{
+        outputId: string;
+        error: unknown;
+    }>;
+}