@endge/core 1.2.5 → 1.2.7

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;
+    }>;
+}

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

@@ -0,0 +1,315 @@
+/** Сигналы, которые поддерживает первая версия модуля диагностики. */
+export type DiagnosticsSignal = 'log' | 'span';
+/** Фаза жизненного цикла, в которой создана диагностическая запись. */
+export type DiagnosticsPhase = 'authoring' | 'build' | 'runtime';
+/** Базовые значения OpenTelemetry SeverityNumber, используемые публичным API. */
+export type DiagnosticsSeverityNumber = 1 | 5 | 9 | 13 | 17 | 21;
+/** Скалярное значение диагностического атрибута. */
+export type DiagnosticsAttributeScalar = string | number | boolean;
+/** Допустимое значение диагностического атрибута. */
+export type DiagnosticsAttributeValue = DiagnosticsAttributeScalar | DiagnosticsAttributeScalar[];
+/** Плоские структурированные атрибуты записи. */
+export type DiagnosticsAttributes = Record<string, DiagnosticsAttributeValue>;
+/** Синхронный provider общих attributes, актуальных в момент создания record. */
+export type DiagnosticsContextProvider = () => DiagnosticsAttributes;
+/** Фаза, в которой обнаружена актуальная проблема системы. */
+export type DiagnosticsProblemPhase = DiagnosticsPhase;
+/** Уровень актуальной проблемы, независимый от OTel SeverityNumber. */
+export type DiagnosticsProblemSeverity = 'info' | 'warning' | 'error' | 'fatal';
+/** Стабильная ссылка на доменную сущность без ограничения compiled ProgramEntityType. */
+export interface DiagnosticsEntityRef {
+    entityType: string;
+    id: string | number;
+    identity: string;
+}
+/** Владелец replaceable-набора проблем. */
+export interface DiagnosticsProblemOwner {
+    /** Уникальный ключ владельца внутри problem registry. */
+    key: string;
+    /** Фаза жизненного цикла, к которой относится набор. */
+    phase: DiagnosticsProblemPhase;
+    /** Доменная сущность, если проблема связана с persisted document. */
+    entityRef?: DiagnosticsEntityRef;
+    /** Runtime instance, если проблема относится к живому host. */
+    runtimeId?: string;
+}
+/** Вход одной проблемы до добавления owner и временных метаданных registry. */
+export interface DiagnosticsProblemInput {
+    /** Стабильный ключ проблемы внутри одного owner; при отсутствии выводится из содержимого. */
+    key?: string;
+    severity: DiagnosticsProblemSeverity;
+    code: string;
+    message: string;
+    sourcePath?: string;
+    start?: number;
+    end?: number;
+    attributes?: DiagnosticsAttributes;
+    traceId?: string;
+    recordId?: number;
+}
+/** Актуальная проблема, нормализованная problem registry. */
+export interface DiagnosticsProblem extends Omit<DiagnosticsProblemInput, 'key'> {
+    /** Стабильный id в формате `<owner.key>:<problem.key>`. */
+    id: string;
+    /** Ключ проблемы внутри owner. */
+    key: string;
+    owner: DiagnosticsProblemOwner;
+    updatedAt: number;
+}
+/** Условия выбора актуальных проблем. */
+export interface DiagnosticsProblemFilter {
+    ownerKeys?: string[];
+    phases?: DiagnosticsProblemPhase[];
+    severities?: DiagnosticsProblemSeverity[];
+    entityTypes?: string[];
+    entityId?: string | number;
+    entityIdentity?: string;
+    runtimeId?: string;
+    codes?: string[];
+}
+/** Snapshot replaceable problem registry. */
+export interface DiagnosticsProblemsSnapshot {
+    revision: number;
+    total: number;
+    problems: readonly DiagnosticsProblem[];
+}
+/** Модуль или библиотека, создавшая запись. */
+export interface DiagnosticsInstrumentationScope {
+    name: string;
+    version?: string;
+}
+/** Общие атрибуты текущего запуска Endge. */
+export interface DiagnosticsResource {
+    attributes: DiagnosticsAttributes;
+}
+/** Статус завершённого span. */
+export interface DiagnosticsSpanStatus {
+    code: 'unset' | 'ok' | 'error';
+    message?: string;
+}
+/** Общие поля любой записи локального diagnostics store. */
+export interface DiagnosticsRecordBase {
+    id: number;
+    signal: DiagnosticsSignal;
+    scope: DiagnosticsInstrumentationScope;
+    attributes: DiagnosticsAttributes;
+    traceId?: string;
+    spanId?: string;
+    traceFlags?: number;
+    phase?: DiagnosticsPhase;
+}
+/** Структурированный log record в формате, близком к OpenTelemetry. */
+export interface DiagnosticsLogRecord extends DiagnosticsRecordBase {
+    signal: 'log';
+    timestamp: number;
+    observedTimestamp?: number;
+    severityNumber: DiagnosticsSeverityNumber;
+    severityText: 'TRACE' | 'DEBUG' | 'INFO' | 'WARN' | 'ERROR' | 'FATAL';
+    body: string;
+    eventName?: string;
+}
+/** Один завершённый span; start/end records отдельно не сохраняются. */
+export interface DiagnosticsSpanRecord extends DiagnosticsRecordBase {
+    signal: 'span';
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    startTimestamp: number;
+    endTimestamp: number;
+    durationMs: number;
+    status: DiagnosticsSpanStatus;
+}
+/** Объединённый тип записей модуля диагностики. */
+export type DiagnosticsRecord = DiagnosticsLogRecord | DiagnosticsSpanRecord;
+/** Настройки локального сбора и bounded storage. */
+export interface EndgeDiagnosticsCollectionConfiguration {
+    enabled: boolean;
+    signals: DiagnosticsSignal[];
+    minSeverity: DiagnosticsSeverityNumber;
+    maxRecords: number;
+}
+/** JSON-safe значение persisted options конкретного adapter. */
+export type DiagnosticsAdapterOptionValue = string | number | boolean | null | DiagnosticsAdapterOptionValue[] | {
+    [key: string]: DiagnosticsAdapterOptionValue;
+};
+/** Именованный канал вывода, создаваемый через adapter registry. */
+export interface EndgeDiagnosticsOutputConfiguration {
+    id: string;
+    name: string;
+    enabled: boolean;
+    adapterType: string;
+    options: Record<string, DiagnosticsAdapterOptionValue>;
+}
+/** Условия выбора records для подписки или route. */
+export interface DiagnosticsFilter {
+    signals?: DiagnosticsSignal[];
+    phases?: DiagnosticsPhase[];
+    minSeverity?: DiagnosticsSeverityNumber;
+    spanStatuses?: DiagnosticsSpanStatus['code'][];
+    minDurationMs?: number;
+    scopes?: string[];
+    eventNames?: string[];
+    traceId?: string;
+    spanId?: string;
+    attributes?: DiagnosticsAttributes;
+    limit?: number;
+}
+/** Декларативное правило доставки records в adapter. */
+export interface EndgeDiagnosticsRoute {
+    id: string;
+    name: string;
+    enabled: boolean;
+    match: DiagnosticsFilter;
+    outputId: string;
+}
+/** Effective configuration сбора и внешней доставки telemetry. */
+export interface EndgeDiagnosticsTelemetryConfiguration {
+    collection: EndgeDiagnosticsCollectionConfiguration;
+    outputs: EndgeDiagnosticsOutputConfiguration[];
+    routes: EndgeDiagnosticsRoute[];
+}
+/** Состав JSON snapshot по умолчанию. */
+export interface EndgeDiagnosticsSnapshotContentConfiguration {
+    telemetry: boolean;
+    problems: boolean;
+    configuration: boolean;
+}
+/** Условия автоматического snapshot по ERROR/FATAL records. */
+export interface EndgeDiagnosticsAutomaticSnapshotConfiguration {
+    enabled: boolean;
+    errorCount: number;
+    windowSeconds: number;
+    cooldownSeconds: number;
+    outputIds: string[];
+}
+/** Effective configuration ручных и автоматических snapshots. */
+export interface EndgeDiagnosticsSnapshotsConfiguration {
+    content: EndgeDiagnosticsSnapshotContentConfiguration;
+    automatic: EndgeDiagnosticsAutomaticSnapshotConfiguration;
+}
+/** Полная effective configuration модуля диагностики. */
+export interface EndgeDiagnosticsConfiguration {
+    telemetry: EndgeDiagnosticsTelemetryConfiguration;
+    snapshots: EndgeDiagnosticsSnapshotsConfiguration;
+}
+/** Параметры записи log без выбранного уровня severity. */
+export interface DiagnosticsLogOptions {
+    timestamp?: number;
+    observedTimestamp?: number;
+    scope?: DiagnosticsInstrumentationScope;
+    eventName?: string;
+    attributes?: DiagnosticsAttributes;
+    traceId?: string;
+    spanId?: string;
+    traceFlags?: number;
+    phase?: DiagnosticsPhase;
+}
+/** Полный input универсального метода log(). */
+export interface DiagnosticsLogInput extends DiagnosticsLogOptions {
+    body: string;
+    severityNumber: DiagnosticsSeverityNumber;
+}
+/** Параметры структурированной записи исключения. */
+export interface DiagnosticsExceptionOptions extends DiagnosticsLogOptions {
+    severityNumber?: 17 | 21;
+}
+/** Параметры создания root или child span. */
+export interface DiagnosticsSpanOptions {
+    scope?: DiagnosticsInstrumentationScope;
+    attributes?: DiagnosticsAttributes;
+    traceId?: string;
+    parentSpanId?: string;
+    traceFlags?: number;
+    startTimestamp?: number;
+    phase?: DiagnosticsPhase;
+}
+/** Параметры завершения span. */
+export interface DiagnosticsSpanEndOptions {
+    status?: DiagnosticsSpanStatus['code'];
+    message?: string;
+    attributes?: DiagnosticsAttributes;
+    endTimestamp?: number;
+}
+/** Публичный handle активного span. */
+export interface DiagnosticsSpanHandle {
+    readonly traceId: string;
+    readonly spanId: string;
+    readonly parentSpanId?: string;
+    readonly isEnded: boolean;
+    /** Добавляет или переопределяет структурированные атрибуты активного span. */
+    setAttributes(attributes: DiagnosticsAttributes): void;
+    /** Создаёт child span с унаследованными trace id и parent span id. */
+    startChild(name: string, options?: Omit<DiagnosticsSpanOptions, 'traceId' | 'parentSpanId'>): DiagnosticsSpanHandle;
+    /** Записывает log, автоматически связанный с текущим span. */
+    log(input: Omit<DiagnosticsLogInput, 'traceId' | 'spanId'>): DiagnosticsLogRecord | null;
+    /** Записывает exception log, автоматически связанный с текущим span. */
+    recordException(error: unknown, options?: DiagnosticsExceptionOptions): DiagnosticsLogRecord | null;
+    /** Завершает span и сохраняет единственный итоговый span record. */
+    end(options?: DiagnosticsSpanEndOptions): DiagnosticsSpanRecord | null;
+}
+/** Счётчики текущей diagnostics session. */
+export interface DiagnosticsCounters {
+    totalRecords: number;
+    droppedByPolicy: number;
+    droppedByCapacity: number;
+    adapterFailures: number;
+    listenerFailures: number;
+    contextProviderFailures: number;
+    activeAdapters: number;
+    activeContextProviders: number;
+    activeSpans: number;
+    recordsBySignal: Partial<Record<DiagnosticsSignal, number>>;
+    recordsByScope: Record<string, number>;
+}
+/** Параметры создания JSON-safe snapshot. */
+export interface DiagnosticsSnapshotOptions {
+    trigger?: 'manual' | 'automatic';
+    includeTelemetry?: boolean;
+    includeProblems?: boolean;
+    includeConfiguration?: boolean;
+    filter?: DiagnosticsFilter;
+}
+/** Telemetry-часть диагностического snapshot. */
+export interface DiagnosticsTelemetrySnapshot {
+    sessionId: string;
+    resource: DiagnosticsResource;
+    counters: DiagnosticsCounters;
+    records: readonly DiagnosticsRecord[];
+}
+/** JSON-safe snapshot текущего состояния diagnostics facade. */
+export interface DiagnosticsSnapshot {
+    generatedAt: number;
+    trigger: 'manual' | 'automatic';
+    telemetry?: DiagnosticsTelemetrySnapshot;
+    problems?: DiagnosticsProblemsSnapshot;
+    configuration?: EndgeDiagnosticsConfiguration;
+}
+/** Обработчик одной принятой диагностической записи. */
+export type DiagnosticsListener = (record: DiagnosticsRecord) => void;
+/** Параметры подписки на diagnostics stream. */
+export interface DiagnosticsSubscribeOptions {
+    replayStored?: boolean;
+}
+/** Внутренний port, через который span пишет records в модуль. */
+export interface DiagnosticsSpanOwner {
+    /** Создаёт root или child span от имени handle. */
+    startSpan(name: string, options?: DiagnosticsSpanOptions): DiagnosticsSpanHandle;
+    /** Записывает нормализованный log от имени handle. */
+    log(input: DiagnosticsLogInput): DiagnosticsLogRecord | null;
+    /** Записывает нормализованное исключение от имени handle. */
+    recordException(error: unknown, options?: DiagnosticsExceptionOptions): DiagnosticsLogRecord | null;
+    /** Финализирует активный span и создаёт итоговый record. */
+    finishSpan(input: {
+        traceId: string;
+        spanId: string;
+        parentSpanId?: string;
+        traceFlags?: number;
+        phase?: DiagnosticsPhase;
+        name: string;
+        scope: DiagnosticsInstrumentationScope;
+        startTimestamp: number;
+        attributes: DiagnosticsAttributes;
+        options?: DiagnosticsSpanEndOptions;
+    }): DiagnosticsSpanRecord | null;
+}

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

@@ -0,0 +1,2 @@
+export * from './diagnostics-adapter.type';
+export * from './diagnostics.types';

package/dist/domain/types/{codegen.types.d.ts → document/codegen.types.d.ts}

@@ -2,22 +2,17 @@ export type EndgeProjectId = string;
 export type EndgeEnvId = string;
 export type EndgeTenantId = string;
 export type EndgeFolderId = string;
-export type EndgeSettingsId = string;
 export type EndgeTypeId = string;
 export type EndgeQueryId = string;
 export type EndgeComponentId = string;
-export type EndgeScenarioId = string;
 export type EndgeActionId = string;
 export type EndgeConverterId = string;
 export type EndgeIntegrationId = string;
-export type EndgeViewId = string;
 export type EndgePageTemplateId = string;
 export type EndgePageId = string;
 export type EndgeNavigationId = string;
 export type EndgeParameterId = string;
 export type EndgeFilterId = string;
-export type EndgeBehaviorBindingId = string;
-export type EndgePresentationBindingId = string;
 export type EndgePolicyId = string;
 export type EndgeStyleId = string;
 export type EndgeVocabId = string;

package/dist/domain/types/document/document-create.type.d.ts

@@ -0,0 +1,18 @@
+import { DomainDocumentType } from './document.types';
+/** Запрос на безопасное создание нового документа без update существующего identity. */
+export type DocumentCreateRequest = {
+    documentType: DomainDocumentType;
+    identity: string;
+    mode: 'model';
+    model: unknown;
+} | {
+    documentType: DomainDocumentType;
+    identity: string;
+    mode: 'payload';
+    payload: Record<string, unknown>;
+};
+/** Результат create-flow после регистрации документа в домене. */
+export interface DocumentCreateResult {
+    documentType: DomainDocumentType;
+    identity: string;
+}