@endge/core 4.0.3 → 6.0.0

package/dist/features/core/modules/source/domain/types/composition-source.types.d.ts

@@ -0,0 +1,408 @@
+import { ComponentSFCInteractionTrigger } from '../../../domain/types/component/sfc/ir.types';
+import { ComponentSFCEventInputValue } from '../../../domain/types/component/sfc/ports.types';
+import { I18nCompiledLocales } from '../../../i18n/domain/i18n.types';
+import { EndgeMockReference } from '../../../mock/domain/types/mock-data.type';
+import { ProgramMetadataMap } from '../../../program/domain/types/program-metadata.types';
+import { ProgramDiagnostic } from '../../../program/domain/types/program.types';
+import { RuntimeHost } from '../../../runtime/domain/runtime-host.types';
+import { RuntimeScopeHandle } from '../../../runtime/domain/runtime-scope.types';
+import { VocabLoadPolicy } from '../../../runtime/domain/vocab-cache.types';
+import { FilterViewControlDefinition } from './filter-view.type';
+import { SourceExpressionIR, SourceFieldDefinition } from './source-expression.types';
+import { UpdateMutationStrategy } from './update-source.types';
+import { EndgeDataMode } from '../../../workspace/domain/workspace.types';
+export type CompositionRuntimeKind = 'filter' | 'query' | 'component' | 'composition' | 'stream' | 'filter-view';
+export type CompositionActivationMode = 'startup' | 'manual';
+export interface CompositionActivationDescriptor {
+    mode: CompositionActivationMode;
+}
+interface CompositionResourceDescriptorBase {
+    name: string;
+    path: string;
+    scopePath: string;
+    sourceOrder: number;
+}
+type CompositionSourceAssetResourceDescriptor = CompositionResourceDescriptorBase & {
+    kind: 'style' | 'i18n';
+    identity: string;
+};
+type CompositionOperationHistoryResourceDescriptor = CompositionResourceDescriptorBase & {
+    kind: 'operation-history';
+    operationHistory: {
+        limit: number;
+        limitConfigurationPath: string | null;
+        shortcuts: OperationHistoryShortcutDescriptor[] | null;
+    };
+};
+export type CompositionResourceDescriptor = CompositionSourceAssetResourceDescriptor | CompositionOperationHistoryResourceDescriptor;
+export interface OperationHistoryShortcutDescriptor {
+    command: 'undo' | 'redo';
+    triggerSet: {
+        kind: 'configuration';
+        path: string;
+    } | {
+        kind: 'literal';
+        value: ComponentSFCInteractionTrigger[];
+    };
+}
+/** Материализованный i18n-resource внутри Composition program artifact. */
+export interface CompositionI18nResourceArtifact {
+    name: string;
+    path: string;
+    scopePath: string;
+    identity: string;
+    sourceOrder: number;
+    messages: I18nCompiledLocales;
+}
+export interface CompositionScopeDescriptor {
+    name: string;
+    /** Публичный path; implicit scope_default имеет path "scope_default". */
+    path: string;
+    parentPath: string | null;
+    activationOverride: CompositionActivationDescriptor | null;
+    effectiveActivation: CompositionActivationDescriptor;
+    /** Data dependencies, активируемые вместе с lifecycle scope. */
+    data?: string[];
+    resources: string[];
+    runtimes: string[];
+    children: string[];
+    sourceOrder: number;
+}
+export type CompositionBindingValue = {
+    kind: 'literal';
+    value: unknown;
+} | {
+    kind: 'output';
+    runtime: string;
+    output: string;
+} | {
+    kind: 'outputs';
+    runtime: string;
+    outputs?: string[];
+} | {
+    kind: 'store';
+    key: string;
+} | {
+    kind: 'data';
+    data: string;
+    path: string;
+} | {
+    kind: 'runtime-metadata';
+    runtime: string;
+    namespace?: string;
+} | {
+    kind: 'filter-fields';
+    runtime: string;
+    fields: string[];
+} | {
+    kind: 'data-view';
+    data: string;
+    path: string;
+    identity: string;
+    props: Record<string, CompositionBindingValue>;
+} | {
+    kind: 'expression';
+    expression: SourceExpressionIR;
+};
+export interface CompositionDataDescriptor {
+    name: string;
+    /** Полный data path. Для root data совпадает с name. */
+    path?: string;
+    /** Lifecycle scope, которому принадлежит dependency. */
+    scopePath?: string;
+    kind: 'store' | 'vocab';
+    identity: string;
+    /** Политика разрешения Store; для Vocab не используется. */
+    resolution?: 'contextual' | 'isolated' | 'injected';
+    /** Provider slot для нескольких Store instances с одной identity. */
+    slot?: string | null;
+    /** Нормализованная политика загрузки Vocab; для Store не используется. */
+    policy?: VocabLoadPolicy;
+}
+export interface CompositionStorePublication {
+    data: string;
+    fields: Record<string, string>;
+}
+export interface CompositionFilterFieldsSlice {
+    kind: 'filter-fields';
+    runtimeId: string;
+    runtimeName: string;
+    fieldKeys: string[];
+    fields: SourceFieldDefinition[];
+    values: Record<string, unknown>;
+}
+export interface CompositionRuntimeDescriptor {
+    name: string;
+    /** Полный публичный path runtime внутри Composition. */
+    path: string;
+    /** Внутренний путь, владеющий RuntimeScope. */
+    scopePath: string;
+    /** Смещения Source для authoring-инструментов; runtime их не интерпретирует. */
+    sourceLocations?: {
+        runtime: {
+            start: number;
+            end: number;
+        };
+        call: {
+            start: number;
+            end: number;
+        };
+        withProps: {
+            start: number;
+            end: number;
+        } | null;
+    };
+    kind: CompositionRuntimeKind;
+    identity: string;
+    /** Явный override в месте вызова runtime. */
+    activationOverride: CompositionActivationDescriptor | null;
+    /** Compiler-linked activation, которую runtime применяет без интерпретации source. */
+    effectiveActivation: CompositionActivationDescriptor;
+    fields?: string[];
+    controls?: Record<string, FilterViewControlDefinition>;
+    componentIdentity?: string;
+    persistKey?: string;
+    props: Record<string, CompositionBindingValue>;
+    /** Локальный data alias child -> data alias owner Composition. */
+    dataBindings?: Record<string, string>;
+    storeTo: CompositionStorePublication[];
+    /** Псевдонимы данных Store, получающие нормализованные события Stream. */
+    dispatchTo?: string[];
+    /** Необязательная политика пакетной обработки событий, принадлежащая Composition. */
+    batch?: {
+        maxItems: number;
+        maxWaitMs: number;
+    };
+}
+export interface CompositionRuntimeChildHandle {
+    name: string;
+    descriptor: CompositionRuntimeDescriptor;
+    runtime: RuntimeHost<any, any>;
+}
+/** Источник изменения для управляемого повторного запуска Query. */
+export type CompositionChangeSource = {
+    kind: 'runtime-output';
+    runtime: string;
+    output: string;
+} | {
+    kind: 'prop';
+    path: string;
+};
+export type CompositionHook = {
+    kind: 'mount';
+    target: string;
+} | {
+    kind: 'change';
+    source: CompositionChangeSource;
+    target: string;
+    debounceMs: number;
+} | {
+    kind: 'success';
+    runtime: string;
+    target: string;
+} | CompositionComponentEventHook;
+export interface ComponentEventApplyUpdateEffect {
+    kind: 'apply-update';
+    data: string;
+    update: string;
+    input?: ComponentSFCEventInputValue;
+}
+export interface ComponentEventStoreMutationEffect {
+    kind: 'mutate-store';
+    data: string;
+    mutation: {
+        strategy: UpdateMutationStrategy;
+        path: string;
+        value?: ComponentSFCEventInputValue;
+        vars?: Record<string, ComponentSFCEventInputValue>;
+    };
+}
+export interface ComponentEventExecuteActionEffect {
+    kind: 'execute-action';
+    action: string;
+    input?: ComponentSFCEventInputValue;
+}
+export type CompositionComponentEventEffect = ComponentEventApplyUpdateEffect | ComponentEventStoreMutationEffect | ComponentEventExecuteActionEffect;
+export interface CompositionComponentEventHook {
+    kind: 'event';
+    runtime: string;
+    event: string;
+    effect: CompositionComponentEventEffect;
+}
+export interface CompositionRuntimeOutputDescriptor {
+    key: string;
+    kind: 'runtime';
+    runtime: string;
+    output?: string;
+}
+export interface CompositionScopeOutputDescriptor {
+    key: string;
+    kind: 'scope';
+    scope: string;
+}
+export type CompositionOutputDescriptor = CompositionRuntimeOutputDescriptor | CompositionScopeOutputDescriptor;
+export type CompositionPreviewLiteral = null | string | number | boolean | CompositionPreviewLiteral[] | {
+    [key: string]: CompositionPreviewLiteral;
+};
+export type CompositionPreviewPropValue = {
+    kind: 'literal';
+    value: CompositionPreviewLiteral;
+} | EndgeMockReference;
+export type CompositionPreviewProps = Record<string, CompositionPreviewPropValue>;
+export interface CompositionSourceDocument {
+    /** Локальный override режима данных; отсутствие значения наследует runtime ancestry. */
+    dataMode?: EndgeDataMode | null;
+    activation: CompositionActivationDescriptor | null;
+    /** Публичный props contract Composition. */
+    props: SourceFieldDefinition[];
+    /** Preview-only fixtures. Не являются runtime defaults. */
+    previewProps?: CompositionPreviewProps | null;
+    data: CompositionDataDescriptor[];
+    resources: CompositionResourceDescriptor[];
+    scopes: CompositionScopeDescriptor[];
+    runtimes: CompositionRuntimeDescriptor[];
+    hooks: CompositionHook[];
+    outputs: CompositionOutputDescriptor[];
+}
+/** Добавление data dependency в canonical Composition source. */
+export interface CompositionSourceAddDataPatch {
+    type: 'add-data';
+    name: string;
+    kind: CompositionDataDescriptor['kind'];
+    identity: string;
+}
+/** Добавление owned resource в canonical Composition source. */
+export interface CompositionSourceAddResourcePatch {
+    type: 'add-resource';
+    name: string;
+    kind: CompositionResourceDescriptor['kind'];
+    identity?: string;
+}
+/** Добавление runtime dependency в canonical Composition source. */
+export interface CompositionSourceAddRuntimePatch {
+    type: 'add-runtime';
+    name: string;
+    kind: Exclude<CompositionRuntimeKind, 'filter-view'>;
+    identity: string;
+    activation?: CompositionActivationMode;
+}
+/** Одна узкая source-preserving операция над Composition dependencies. */
+export type CompositionSourcePatchOperation = CompositionSourceAddDataPatch | CompositionSourceAddResourcePatch | CompositionSourceAddRuntimePatch;
+/** Composition source patch: одиночная операция или атомарная пачка. */
+export type CompositionSourcePatch = CompositionSourcePatchOperation | CompositionSourcePatchOperation[];
+/** Нормализованная связь input runtime-ноды. */
+export interface CompositionRuntimeInputConnection {
+    targetRuntime: string;
+    targetProp: string;
+    source: CompositionBindingValue;
+}
+/** Явная передача Store data из owner Composition во вложенную Composition. */
+export interface CompositionRuntimeDataConnection {
+    targetRuntime: string;
+    targetData: string;
+    sourceData: string;
+}
+/** Нормализованный trigger логического update runtime-ноды. */
+export interface CompositionRuntimeUpdateConnection {
+    id: string;
+    source: CompositionChangeSource;
+    targetRuntime: string;
+    updateKind: 'run';
+    debounceMs: number;
+}
+/** Запуск target Query после успешного выполнения source Query. */
+export interface CompositionRuntimeSuccessConnection {
+    id: string;
+    sourceRuntime: string;
+    targetRuntime: string;
+    updateKind: 'run';
+}
+/** Публикация output runtime-ноды в Composition data. */
+export interface CompositionRuntimePublicationConnection {
+    id: string;
+    sourceRuntime: string;
+    sourceOutput: string;
+    targetData: string;
+    targetPath: string;
+}
+/** Действие, выполняемое после mount всего графа. */
+export interface CompositionRuntimeMountConnection {
+    targetRuntime: string;
+    updateKind: 'run';
+}
+export interface CompositionRuntimeEventConnection extends CompositionComponentEventHook {
+    id: string;
+}
+/** Исполняемый граф Composition, построенный компилятором из source document. */
+export interface CompositionRuntimeGraph {
+    inputs: CompositionRuntimeInputConnection[];
+    dataInputs?: CompositionRuntimeDataConnection[];
+    updates: CompositionRuntimeUpdateConnection[];
+    /** Optional для чтения artifacts, скомпилированных до появления onSuccess. */
+    successes?: CompositionRuntimeSuccessConnection[];
+    publications: CompositionRuntimePublicationConnection[];
+    mounts: CompositionRuntimeMountConnection[];
+    /** Семантические эффекты Event компонента, принадлежащие этой Composition. */
+    events?: CompositionRuntimeEventConnection[];
+}
+/** Payload Composition artifact без runtime state. */
+export interface CompositionProgramPayload extends CompositionSourceDocument {
+    type: 'composition';
+    sourceVersion: number;
+    /** Снимки словарей, которые runtime читает без обращения к Domain. */
+    i18nResources?: CompositionI18nResourceArtifact[];
+    graph: CompositionRuntimeGraph;
+}
+export interface CompositionSourceCompileResult {
+    ast: unknown | null;
+    document: CompositionSourceDocument | null;
+    artifact: CompositionProgramPayload | null;
+    metadata: ProgramMetadataMap;
+    diagnostics: Omit<ProgramDiagnostic, 'entityRef'>[];
+}
+export interface CompositionRuntimeOutputHandle {
+    kind: 'runtime';
+    runtime: RuntimeHost<any, any> | null;
+    output?: string;
+}
+/** Публичный контракт Composition host без зависимости Domain от concrete Model runtime. */
+export interface CompositionRuntimeHostHandle extends RuntimeHost<'composition', any, CompositionProgramPayload> {
+    mountGraph: () => Promise<void>;
+    getChild: (name: string) => RuntimeHost<any, any> | null;
+    getChildren: () => CompositionRuntimeChildHandle[];
+    getFilterFieldsSlice: (runtimeName: string, fieldKeys: string[]) => CompositionFilterFieldsSlice | null;
+    getOutputs: () => Readonly<Record<string, CompositionPublicOutputHandle>>;
+    getScope: (path: string) => RuntimeScopeHandle | null;
+    getRuntimeHandle: (path: string) => CompositionRuntimeActivationHandle | null;
+    getOutput: (name: string) => unknown;
+    getDataSnapshot: () => Readonly<Record<string, unknown>>;
+    getProps: () => Readonly<Record<string, unknown>>;
+    getDataPath: (name: string, path?: string) => string;
+}
+export interface CompositionRuntimeActivationHandle {
+    readonly path: string;
+    readonly state: 'inactive' | 'active' | 'paused' | 'disposed';
+    readonly runtime: RuntimeHost<any, any> | null;
+    activate: () => Promise<RuntimeHost<any, any>>;
+    pause: () => Promise<void>;
+    resume: () => Promise<void>;
+    deactivate: () => Promise<void>;
+    dispose: () => Promise<void>;
+    getOutput: (name: string) => unknown;
+}
+export type CompositionPublicOutputHandle = CompositionRuntimeOutputHandle | CompositionRuntimeActivationHandle | RuntimeScopeHandle;
+export interface CompositionMountOptions {
+    id?: string;
+    /** Значения публичных Composition props для standalone mount. */
+    props?: Record<string, unknown>;
+    /** Явные runtime-id Store instances для data aliases. */
+    dataRuntimes?: Record<string, string>;
+}
+export interface CompositionSession<THost extends CompositionRuntimeHostHandle = CompositionRuntimeHostHandle> {
+    id: string;
+    host: THost;
+    outputs: Readonly<Record<string, CompositionPublicOutputHandle>>;
+    output: <T = unknown>(name: string) => T | undefined;
+    unmount: () => Promise<void>;
+}
+export {};

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

@@ -0,0 +1,47 @@
+import { ProgramDiagnostic } from '../../../program/domain/types/program.types';
+import { TypeSourceExpression } from './type-source.types';
+/** Сохраняемое JSON-сериализуемое значение конфигурации. */
+export type EndgeJSONValue = null | boolean | number | string | EndgeJSONValue[] | {
+    [key: string]: EndgeJSONValue;
+};
+/** Одна пользовательская настройка на основе Source. */
+export interface ConfigurationSourceValueDefinition {
+    key: string;
+    type: TypeSourceExpression;
+    defaultValue: EndgeJSONValue;
+    defaultWasInferred: boolean;
+    label: string;
+    description?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+}
+/** Канонический документ Configuration Source v1. */
+export interface ConfigurationSourceDocument {
+    values: ConfigurationSourceValueDefinition[];
+}
+/** Ранний артефакт Configuration для компилятора. */
+export interface ConfigurationProgramPayload {
+    type: 'configuration';
+    identity: string;
+    displayName: string;
+    sourceVersion: 1;
+    values: ConfigurationSourceValueDefinition[];
+}
+export interface ConfigurationSourceCompileResult {
+    ast: unknown | null;
+    document: ConfigurationSourceDocument | null;
+    /** Best-effort проекция AST для визуального исправления, когда семантическая диагностика блокирует компиляцию. */
+    draftDocument?: ConfigurationSourceDocument | null;
+    diagnostics: Omit<ProgramDiagnostic, 'entityRef'>[];
+}
+export interface EndgeConfigurationSchemaEntry {
+    id: string | number;
+    identity: string;
+    displayName: string;
+    description?: string | null;
+    sourceVersion: number;
+    document: ConfigurationSourceDocument | null;
+    diagnostics: Omit<ProgramDiagnostic, 'entityRef'>[];
+    status: 'valid' | 'warning' | 'error';
+}

package/dist/features/core/modules/source/domain/types/data-view-source.types.d.ts

@@ -0,0 +1,128 @@
+import { ProgramMetadataMap } from '../../../program/domain/types/program-metadata.types';
+import { ProgramDiagnostic } from '../../../program/domain/types/program.types';
+import { SourceExpressionIR, SourceFieldDefinition } from './source-expression.types';
+export type DataViewSourceMode = 'manual' | 'pipeline' | 'projection' | 'expression';
+export type DataViewIncrementalRequest = {
+    mode: 'auto';
+} | {
+    mode: 'full';
+} | {
+    mode: 'collection-by-key';
+    key: string;
+} | {
+    mode: 'filter-by-key';
+    key: string;
+};
+export type DataViewMaterializationStrategy = {
+    kind: 'full';
+} | {
+    kind: 'collection-by-key';
+    key: string;
+} | {
+    kind: 'filter-by-key';
+    key: string;
+};
+export interface DataViewSourceContract {
+    input: SourceFieldDefinition;
+    output: SourceFieldDefinition;
+}
+export interface DataViewSourceDocument {
+    mode: DataViewSourceMode;
+    incremental: DataViewIncrementalRequest;
+    props: SourceFieldDefinition[];
+    contract?: DataViewSourceContract | null;
+    filter?: SourceExpressionIR | null;
+    transform?: DataViewManualTransform;
+    steps?: DataViewPipelineStep[];
+    output?: Record<string, SourceExpressionIR>;
+    expression?: SourceExpressionIR;
+}
+/** Runtime-контекст одного вызова parameterized DataView. */
+export interface DataViewRunContext {
+    props?: Record<string, unknown>;
+}
+export interface DataViewManualTransform {
+    params: string[];
+    body: string;
+}
+export type DataViewPipelineStep = DataViewFromStep | DataViewJoinStep | DataViewMapStep | DataViewSelectStep;
+export interface DataViewSelectStep {
+    type: 'select';
+    expression: SourceExpressionIR;
+}
+export interface DataViewFromStep {
+    type: 'from';
+    source: string;
+    as: string;
+    dataViews?: DataViewRef[];
+}
+export type DataViewRef = DataViewExternalRef | DataViewInlineRef | DataViewLocalRef;
+export interface DataViewExternalRef {
+    kind: 'external';
+    identity: string;
+}
+export interface DataViewInlineRef {
+    kind: 'inline';
+    source: string;
+}
+export interface DataViewLocalRef {
+    kind: 'local';
+    ref: {
+        entityType: 'data-view';
+        id: string | number;
+        identity: string;
+    };
+}
+export interface DataViewJoinStep {
+    type: 'join';
+    source: string;
+    left: string;
+    right: string;
+    as: string;
+}
+export interface DataViewMapStep {
+    type: 'map';
+    spreads: DataViewMapSpread[];
+    fields: Record<string, DataViewExpression>;
+}
+export interface DataViewMapSpread {
+    source: string;
+}
+export type DataViewExpression = DataViewPathExpression | DataViewTemplateExpression | DataViewLiteralExpression | SourceExpressionIR;
+export interface DataViewPathExpression {
+    type: 'path';
+    path: string;
+    operations: DataViewPathOperation[];
+}
+export type DataViewPathOperation = {
+    type: 'find';
+    criteria: Record<string, unknown>;
+} | {
+    type: 'pick';
+    path: string;
+} | {
+    type: 'convert';
+    converter: string;
+    options?: Record<string, unknown>;
+};
+export interface DataViewTemplateExpression {
+    type: 'template';
+    template: string;
+}
+export interface DataViewLiteralExpression {
+    type: 'literal';
+    value: unknown;
+}
+export interface DataViewSourceCompileResult {
+    ast: unknown;
+    document: DataViewSourceDocument | null;
+    artifact: unknown | null;
+    metadata: ProgramMetadataMap;
+    diagnostics: Omit<ProgramDiagnostic, 'entityRef'>[];
+}
+export interface DataViewRunTools {
+    convert: (identity: string, value: unknown, options?: Record<string, unknown>) => unknown;
+    pick: (value: unknown, path: string) => unknown;
+    path: (scope: unknown, path: string) => unknown;
+    template: (template: string, scope?: Record<string, unknown>) => string;
+}

package/dist/features/core/modules/source/domain/types/filter-source.types.d.ts

@@ -0,0 +1,104 @@
+import { ProgramMetadataMap } from '../../../program/domain/types/program-metadata.types';
+import { ProgramDiagnostic } from '../../../program/domain/types/program.types';
+import { SourceExpressionIR, SourceFieldDefinition } from './source-expression.types';
+/** Source-описание Filter v1. */
+export interface FilterSourceDocument {
+    fields: SourceFieldDefinition[];
+    outputs: FilterProgramOutput[];
+}
+/** Абсолютный диапазон узла внутри Filter source. */
+export interface FilterSourceRange {
+    start: number;
+    end: number;
+}
+/** Source-backed поле для визуального редактора Filter. */
+export interface FilterSourceEditorField extends SourceFieldDefinition {
+    sourceRange: FilterSourceRange;
+    keyRange: FilterSourceRange;
+    valueRange: FilterSourceRange;
+    valueSource: string;
+    defaultSource: string | null;
+}
+/** Source-backed output для навигации из визуального редактора. */
+export interface FilterSourceEditorOutput {
+    key: string;
+    kind: FilterProgramOutput['kind'];
+    sourceRange: FilterSourceRange;
+    source: string;
+}
+/** Проекция Filter source, которая не хранится отдельно от source. */
+export interface FilterSourceEditorDocument {
+    fields: FilterSourceEditorField[];
+    outputs: FilterSourceEditorOutput[];
+}
+/** Узкие операции визуального редактора над canonical Filter source. */
+export type FilterSourcePatchOperation = {
+    type: 'add-field';
+    key: string;
+    expression: string;
+} | {
+    type: 'remove-field';
+    key: string;
+} | {
+    type: 'move-field';
+    key: string;
+    toIndex: number;
+} | {
+    type: 'rename-field';
+    key: string;
+    nextKey: string;
+} | {
+    type: 'set-field';
+    key: string;
+    expression: string;
+};
+export type FilterSourcePatch = FilterSourcePatchOperation | FilterSourcePatchOperation[];
+/** JSON-output фильтра. */
+export interface FilterProgramJsonOutput {
+    key: string;
+    kind: 'json';
+    expression: SourceExpressionIR;
+    dependencies?: string[];
+}
+/** Локальный predicate, вычисляемый над строкой и state фильтра. */
+export interface FilterProgramPredicateOutput {
+    key: string;
+    kind: 'predicate';
+    expression: SourceExpressionIR;
+    dependencies?: string[];
+}
+export type FilterProgramOutput = FilterProgramJsonOutput | FilterProgramPredicateOutput;
+/** Payload Filter artifact без persisted source и diagnostics envelope. */
+export interface FilterProgramPayload {
+    type: 'filter';
+    sourceVersion: number;
+    fields: SourceFieldDefinition[];
+    defaults: Record<string, SourceExpressionIR | undefined>;
+    outputs: FilterProgramOutput[];
+}
+/** Результат компиляции Filter source. */
+export interface FilterSourceCompileResult {
+    ast: unknown | null;
+    document: FilterSourceDocument | null;
+    artifact: FilterProgramPayload | null;
+    metadata: ProgramMetadataMap;
+    diagnostics: Omit<ProgramDiagnostic, 'entityRef'>[];
+}
+/** Runtime-value одного Filter output. */
+export type FilterRuntimeOutput = {
+    key: string;
+    kind: 'json';
+    value: unknown;
+} | {
+    key: string;
+    kind: 'predicate';
+    test: (row: unknown) => boolean;
+};
+export type FilterRuntimeActionId = 'patch' | 'set' | 'reset' | 'clear';
+export interface FilterRuntimeSetPayload {
+    key: string;
+    value: unknown;
+}
+export interface FilterRuntimeActionHandle {
+    run: (payload?: unknown) => Promise<void>;
+}