@endge/core 2.0.4 → 3.0.2

package/dist/model/modules/runtime/core/endge-actions.d.ts

@@ -1,6 +1,7 @@
 import { RAction } from '../../../../domain/entities/reflect/RAction';
 import { ActionDefinitionInput, ActionExecuteOptions, ImplementationBindingScope, ResolvedActionDescriptor, RuntimeAction, RuntimeActionContext, RuntimeActionId, RuntimeActionRegistrySnapshot } from '../../../../domain/types/runtime/action.types';
 import { ImplementationProvider } from '../../../../domain/types/runtime/implementation.types';
+import { EntityOrigin } from '../../../../domain/types/document/entity-management.type';
 import { Subscribable } from '@endge/utils';
 import { EndgeImplementations } from '../implementation/endge-implementations';
 export interface CodeActionDefinition extends Omit<ActionDefinitionInput, 'owner'> {
@@ -11,14 +12,19 @@ export interface CodeActionDefinition extends Omit<ActionDefinitionInput, 'owner
     canExecute?: ImplementationProvider['canExecute'];
 }
 export interface ActionOverrideInput {
-    owner: string;
-    providerKey?: string;
-    execute?: ImplementationProvider['execute'];
-    canExecute?: ImplementationProvider['canExecute'];
+    identity: string;
+    providerKey: string;
     scope?: Exclude<ImplementationBindingScope, 'default' | 'invocation'>;
     scopeIdentity?: string;
     priority?: number;
 }
+export interface ActionDefinitionDescriptor extends ActionDefinitionInput {
+    origin: EntityOrigin;
+    catalogPath?: readonly string[];
+}
+export interface ActionProviderDescriptor extends Omit<ImplementationProvider, 'contract'> {
+    identity: string;
+}
 /** Action-specific facade over semantic definitions and generic implementations. */
 export declare class EndgeActions extends Subscribable {
     private readonly _implementations;
@@ -27,15 +33,16 @@ export declare class EndgeActions extends Subscribable {
     private readonly _codeActionDisposers;
     private readonly _providerDisposers;
     private _hasSynchronizedResolvedIndex;
+    private readonly _sourceExecutor;
     constructor(_implementations: EndgeImplementations);
     /** Rebuilds code-owned defaults. Local application code registers again after reset. */
     reset(): void;
-    /** Defines a core/plugin Action that has no Payload record. */
-    defineBuiltin(definition: CodeActionDefinition): () => void;
-    /** Defines a session-local Action. Identity collisions must use explicit override(). */
-    defineLocal(definition: CodeActionDefinition): () => void;
+    /** Installs a serializable code-owned semantic definition without executable code. */
+    define(definition: ActionDefinitionDescriptor): () => void;
+    /** Installs executable code separately from its semantic definition. */
+    provide(provider: ActionProviderDescriptor): () => void;
     /** Binds local code over an existing Action without mutating its definition. */
-    override(identity: string, override: ActionOverrideInput): () => void;
+    override(override: ActionOverrideInput): () => void;
     /** Executes a resolved Action through the generic implementation pipeline. */
     execute<TResult = unknown>(identity: RuntimeActionId, optionsOrContext?: ActionExecuteOptions | RuntimeActionContext, legacyPayload?: unknown): Promise<TResult | undefined>;
     /** Returns effective definitions for palettes and the Domain Widget. */
@@ -51,9 +58,6 @@ export declare class EndgeActions extends Subscribable {
     /** Returns the semantic definition regardless of storage origin. */
     getDefinition(identity: string): RAction | null;
     canExecute(id: RuntimeActionId, context: RuntimeActionContext, payload?: unknown): boolean;
-    /** @deprecated Use defineLocal(), defineBuiltin() or override(). */
-    register(action: RuntimeAction): () => void;
-    unregister(id: RuntimeActionId): void;
     serialize(): RuntimeActionRegistrySnapshot;
     private _defineCodeAction;
     private _findAction;

package/dist/model/modules/runtime/core/endge-runtime.d.ts

@@ -15,19 +15,19 @@ import { EndgeProject } from '../execution/endge-project';
 import { EndgeDataView } from '../execution/endge-data-view';
 import { EndgeQuery } from '../execution/endge-query';
 import { EndgeComputation } from '../execution/endge-computation';
-import { EndgeFlow } from '../flow/endge-flow';
-import { EndgeFlowRegistry } from '../flow/endge-flow-registry';
+import { EndgeConverters } from '../execution/endge-converters';
+import { EndgeOperations } from '../operation/endge-operations';
 /** Модуль создания, регистрации и уничтожения runtime hosts и app scopes. */
 export declare class EndgeRuntime extends EndgeModule {
+    readonly implementations: EndgeImplementations;
     readonly computation: EndgeComputation;
+    readonly converters: EndgeConverters;
     readonly query: EndgeQuery;
     readonly dataView: EndgeDataView;
     readonly composition: EndgeComposition;
     readonly project: EndgeProject;
-    readonly flowRegistry: EndgeFlowRegistry;
-    readonly flow: EndgeFlow;
-    readonly implementations: EndgeImplementations;
     readonly actions: EndgeActions;
+    readonly operations: EndgeOperations;
     readonly scopes: RuntimeScopeRegistry;
     private _hosts;
     private _strategies;

package/dist/model/modules/runtime/execution/action/action-program-executor.d.ts

@@ -0,0 +1,13 @@
+import { RuntimeHost } from '../../../../../domain/types/runtime/runtime-host.types';
+import { ActionProgramPayload } from '../../../../../domain/types/program/action-program.types';
+/** Executes compiler-produced Action IR without interpreting Source. */
+export declare class ActionProgramExecutor {
+    run(payload: ActionProgramPayload, input: unknown, parent: RuntimeHost<any, any> | null): Promise<unknown>;
+    private runBlock;
+    private runStep;
+    private runOperation;
+    private evaluate;
+    private findComposition;
+    private requireObject;
+    private optionalObject;
+}

package/dist/model/modules/runtime/execution/computation/EndgeComputation.d.ts

@@ -1,12 +1,45 @@
-import { ComputationSandboxAdapter, ComputationSandboxRequest } from '../../../../../domain/types/computation/computation-runtime.types';
+import { ComputationSandboxAdapter, ComputationSandboxRequest, ComputationOverride } from '../../../../../domain/types/computation/computation-runtime.types';
+import { EntityOrigin } from '../../../../../domain/types/document/entity-management.type';
+import { ImplementationBindingScope } from '../../../../../domain/types/runtime/action.types';
 import { ComputationProgramPayload } from '../../../../../domain/types/computation/computation-program.types';
 import { ProgramArtifact } from '../../../../../domain/types/program/program.types';
 import { ComputationResourceState } from './ComputationResource';
+import { EndgeImplementations } from '../../implementation/endge-implementations';
 /** Executes compiled computation graphs and creates renderer-neutral resources. */
 export declare class EndgeComputation {
+    private readonly implementations;
+    private readonly definitions;
+    private readonly providers;
+    private readonly providerDisposers;
+    private readonly definitionDisposers;
+    private readonly bindingDisposers;
     private sandbox;
     private readonly executor;
     private readonly api;
+    constructor(implementations: EndgeImplementations);
+    hasDefinition(identity: string): boolean;
+    /** Installs a serializable code-owned Computation definition. */
+    define(definition: {
+        identity: string;
+        origin: EntityOrigin;
+        defaultProviderKey?: string;
+        execution?: 'sync' | 'async';
+    }): VoidFunction;
+    /** Installs executable code separately from a Computation definition. */
+    provide(provider: {
+        identity: string;
+        key: string;
+        origin?: EntityOrigin;
+        implementation: ComputationOverride;
+    }): VoidFunction;
+    /** Selects one previously provided implementation without redefining semantics. */
+    override(binding: {
+        identity: string;
+        providerKey: string;
+        scope?: Exclude<ImplementationBindingScope, 'default' | 'invocation'>;
+        scopeIdentity?: string;
+        priority?: number;
+    }): VoidFunction;
     setSandboxAdapter(adapter: ComputationSandboxAdapter | null): void;
     /** Executes an already compiler-validated function in the shared isolated sandbox. */
     executeSandbox(request: ComputationSandboxRequest): Promise<unknown>;
@@ -29,4 +62,6 @@ export declare class EndgeComputation {
     private _enterExecution;
     private runOverrideSync;
     private runOverride;
+    private resolveProvider;
+    reset(): void;
 }

package/dist/model/modules/runtime/execution/endge-converters.d.ts

@@ -0,0 +1,36 @@
+import { EntityOrigin } from '../../../../domain/types/document/entity-management.type';
+import { ImplementationBindingScope } from '../../../../domain/types/runtime/action.types';
+import { EndgeImplementations } from '../implementation/endge-implementations';
+type ConverterProvider = (value: unknown, options?: Record<string, unknown>) => unknown;
+/** Synchronous Converter facade with separate definitions, providers and bindings. */
+export declare class EndgeConverters {
+    private readonly implementations;
+    private readonly definitions;
+    private readonly providerDisposers;
+    private readonly definitionDisposers;
+    private started;
+    constructor(implementations: EndgeImplementations);
+    has(identity: string): boolean;
+    define(definition: {
+        identity: string;
+        origin: EntityOrigin;
+        defaultProviderKey?: string;
+    }): VoidFunction;
+    provide(provider: {
+        identity: string;
+        key: string;
+        origin: EntityOrigin;
+        convert: ConverterProvider;
+    }): VoidFunction;
+    override(binding: {
+        identity: string;
+        providerKey: string;
+        scope?: Exclude<ImplementationBindingScope, 'default' | 'invocation'>;
+        scopeIdentity?: string;
+        priority?: number;
+    }): VoidFunction;
+    execute(identity: string, value: unknown, options?: Record<string, unknown>): unknown;
+    start(): void;
+    reset(): void;
+}
+export {};

package/dist/model/modules/runtime/implementation/endge-implementations.d.ts

@@ -5,10 +5,13 @@ export declare class EndgeImplementations {
     private readonly _bindings;
     /** Registers local executable code and returns its disposer. */
     registerProvider(provider: ImplementationProvider): () => void;
+    hasProvider(key: string): boolean;
     /** Registers an explicit binding and returns its disposer. */
     bind(binding: ImplementationBinding): () => void;
     /** Resolves the effective provider by scope and priority. */
     resolve(request: ImplementationResolutionRequest): ResolvedImplementation;
+    /** Returns null only when neither a binding nor a default provider is declared. */
+    resolveOptional(request: ImplementationResolutionRequest): ResolvedImplementation | null;
     /** Resolves and executes one invocation through its effective provider. */
     execute<TResult = unknown>(request: ImplementationResolutionRequest, invocation: ImplementationInvocation): Promise<TResult>;
     /** Returns a serializable inspection snapshot without functions. */

package/dist/model/modules/runtime/operation/endge-operations.d.ts

@@ -0,0 +1,18 @@
+import { RuntimeHost } from '../../../../domain/types/runtime/runtime-host.types';
+import { RuntimeScope } from '../../../../domain/entities/runtime/RuntimeScope';
+import { OperationHistory } from './operation-history';
+/** Resolves the nearest active Operation History along runtime-scope ancestry. */
+export declare class EndgeOperations {
+    private readonly histories;
+    private latestScopeId;
+    private keydownDisposer;
+    register(scope: RuntimeScope, history: OperationHistory): () => void;
+    resolveForHost(host: RuntimeHost<any, any> | null | undefined): OperationHistory | null;
+    getActiveHistory(): OperationHistory | null;
+    undo(): Promise<unknown>;
+    redo(): Promise<unknown>;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    private ensureShortcuts;
+    private disposeShortcuts;
+}

package/dist/model/modules/runtime/operation/operation-history.d.ts

@@ -0,0 +1,54 @@
+import { RuntimeOwnedResource } from '../../../../domain/types/runtime/runtime-resource.types';
+import { ComponentSFCInteractionTrigger } from '../../../../domain/types/component/sfc/ir.types';
+export interface OperationHistoryShortcutBinding {
+    command: 'undo' | 'redo';
+    triggers: ComponentSFCInteractionTrigger[];
+}
+export interface OperationHistoryEntry {
+    id: string;
+    input: unknown;
+    runOutput: unknown;
+    undo: () => Promise<unknown>;
+    redo: () => Promise<unknown>;
+    undoOutput?: unknown;
+}
+export interface OperationHistoryOptions {
+    id: string;
+    limit?: number;
+    shortcuts?: OperationHistoryShortcutBinding[] | null;
+    onChange?: () => void;
+}
+/** Runtime-memory undo/redo cursor. Transitions are serialized and failures keep the cursor stable. */
+export declare class OperationHistory implements RuntimeOwnedResource {
+    private readonly options;
+    readonly kind = "operation-history";
+    readonly id: string;
+    private entries;
+    private cursor;
+    private paused;
+    private disposed;
+    private queue;
+    private _limit;
+    constructor(options: OperationHistoryOptions);
+    get limit(): number;
+    get shortcuts(): OperationHistoryShortcutBinding[];
+    get active(): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    setLimit(value: number): void;
+    commit(entry: OperationHistoryEntry): void;
+    undo(): Promise<unknown>;
+    redo(): Promise<unknown>;
+    pause(): void;
+    resume(): void;
+    dispose(): void;
+    snapshot(): {
+        limit: number;
+        cursor: number;
+        size: number;
+        paused: boolean;
+    };
+    private enqueue;
+    private trim;
+}
+export declare function defaultOperationHistoryShortcuts(): OperationHistoryShortcutBinding[];

package/dist/model/services/compiler/action/action-compile.d.ts

@@ -1,8 +1,9 @@
 import { RAction } from '../../../../domain/entities/reflect/RAction';
-import { ActionProgramPayload, ProgramDiagnostic } from '../../../../domain/types/program/program.types';
+import { ActionProgramPayload, ProgramDependency, ProgramDiagnostic } from '../../../../domain/types/program/program.types';
 export interface ActionCompileResult {
     payload: ActionProgramPayload;
     diagnostics: Omit<ProgramDiagnostic, 'entityRef'>[];
+    dependencies: ProgramDependency[];
 }
-/** Compiles persisted Flow source and the semantic Action contract into Program. */
+/** Compiles persisted Action Source into Program. */
 export declare function compileAction(entity: RAction): ActionCompileResult;

package/dist/model/services/compiler/component-sfc/component-sfc-ports.d.ts

@@ -6,6 +6,8 @@ export interface ComponentSFCPortAnalysisOptions {
     resolveProvider?: (identity: string, expectedKind: 'computation' | 'component' | 'action' | 'query') => ComponentSFCPortProviderDescriptor | null;
     resolveTypeDefinition?: (identity: string) => TypeSourceDefinition | null;
 }
+/** Compiles one direct reaction or a non-empty ordered reaction array. */
+export declare function compileComponentSFCLocalEventActions(eventName: string, source: string, sourceOffset: number, dependencies: RComponentDependencies, diagnostics: RComponentDiagnostic[], ownerPorts?: ComponentSFCPortManifest | null): ComponentSFCEventAction[];
 /** Compiles the safe reaction grammar used by local `@event` template bindings. */
 export declare function compileComponentSFCLocalEventAction(eventName: string, source: string, sourceOffset: number, dependencies: RComponentDependencies, diagnostics: RComponentDiagnostic[], ownerPorts?: ComponentSFCPortManifest | null): ComponentSFCEventAction | null;
 export interface ComponentSFCPortAnalysisResult {

package/dist/model/services/compiler/computation/computation-compile.d.ts

@@ -1,5 +1,6 @@
 import { ComputationProgramPayload } from '../../../../domain/types/computation/computation-program.types';
 import { ProgramDiagnostic } from '../../../../domain/types/program/program.types';
+import * as t from '@babel/types';
 type DiagnosticDraft = Omit<ProgramDiagnostic, 'entityRef'>;
 export interface ComputationCompileInput {
     source: string;
@@ -10,4 +11,6 @@ export interface ComputationCompileResult {
 }
 /** Compiles defineComputation source into a deterministic output graph. */
 export declare function compileComputation(input: ComputationCompileInput): ComputationCompileResult;
+export declare function validateSandboxBody(node: t.Node, diagnostics: DiagnosticDraft[], sourcePath: string): void;
+export declare function functionSource(node: t.ObjectMethod | t.FunctionExpression | t.ArrowFunctionExpression, source: string): string;
 export {};

package/dist/model/services/source-engine/compilers/action-source-compile.d.ts

@@ -0,0 +1,17 @@
+import { ActionProgramPayload } from '../../../../domain/types/program/action-program.types';
+import { ProgramDependency, ProgramDiagnostic } from '../../../../domain/types/program/program.types';
+import { ActionTargetSelector } from '../../../../domain/types/runtime/action.types';
+type DiagnosticDraft = Omit<ProgramDiagnostic, 'entityRef'>;
+export interface ActionSourceCompileInput {
+    source: string;
+    sourceVersion?: number;
+    target?: ActionTargetSelector[] | null;
+}
+export interface ActionSourceCompileResult {
+    payload: ActionProgramPayload;
+    diagnostics: DiagnosticDraft[];
+    dependencies: ProgramDependency[];
+}
+/** Compiles one canonical defineAction source into deterministic sequential IR. */
+export declare function compileActionSource(input: ActionSourceCompileInput): ActionSourceCompileResult;
+export {};

package/dist/model/services/source-engine/strategies/ActionSourceEngineStrategy.d.ts

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

package/dist/model/services/source-engine/strategies/ActionSourceLanguageStrategy.d.ts

@@ -0,0 +1,23 @@
+import { SourceKind, SourceLanguageCompletion, SourceLanguageContext, SourceLanguageStrategy, SourceLanguageValidationResult } from '../../../../domain/types/source/source-engine.types';
+export declare class ActionSourceLanguageStrategy implements SourceLanguageStrategy {
+    readonly id = "source-language:action";
+    readonly sourceKind: SourceKind;
+    readonly syntax: import('../../../../domain/types/source/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/source-engine.types').SourceDocumentReference | null;
+    signatureHelp(context: SourceLanguageContext): {
+        activeSignature: number;
+        activeParameter: number;
+        signatures: {
+            label: string;
+            documentation: string;
+            parameters: {
+                label: string;
+            }[];
+        }[];
+    } | null;
+    semanticHighlights(context: SourceLanguageContext): import('../../../../domain/types/source/source-engine.types').SourceLanguageSemanticHighlight[];
+}

package/dist/model/services/source-engine/templates/action.default.source.d.ts

@@ -0,0 +1 @@
+export declare const ACTION_DEFAULT_SOURCE = "defineAction({\n  contract: {\n    input: field('Object'),\n    output: field('Object'),\n  },\n\n  steps: {\n    result: input(),\n  },\n\n  output: output('result'),\n})\n";

package/dist/test/fixtures/action-source.d.ts

@@ -0,0 +1 @@
+export declare const ACTION_SOURCE_WITH_OPERATION = "defineAction({\n  contract: {\n    input: field('Object'),\n    output: field('Object'),\n  },\n  steps: {\n    normalized: input('value').convert('string-trim').upperCase(),\n    validation: computation('schedule.validate-carrier', {\n      value: output('normalized'),\n    }),\n    edit: operation({\n      input: {\n        id: input('id'),\n        value: output('normalized'),\n        previousValue: input('previousValue'),\n      },\n      run: {\n        steps: {\n          remote: query({ identity: 'schedule-update', input: input() }),\n        },\n        output: output('remote'),\n      },\n      undo: {\n        steps: {\n          remote: query({ identity: 'schedule-update', input: input() }),\n        },\n        output: output('remote'),\n      },\n    }),\n  },\n  output: {\n    value: output('normalized'),\n    validation: output('validation'),\n    request: output('edit'),\n  },\n})";

package/dist/test/model/modules/context/endge-context-theme-default.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/model/modules/runtime/action-runtime.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/model/modules/runtime/executable-implementations.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/model/modules/runtime/operation-history.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/model/services/compiler/component-sfc/component-sfc-action-reactions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/model/services/source-engine/action-source-compile.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@endge/core",
-  "version": "2.0.4",
+  "version": "3.0.2",
   "private": false,
   "license": "Apache-2.0",
   "type": "module",
@@ -29,7 +29,7 @@
   "dependencies": {
     "@babel/parser": "^7.27.2",
     "@babel/types": "^7.27.1",
-    "@endge/utils": "^0.24.12",
+    "@endge/utils": "^0.24.13",
     "@vue/compiler-dom": "^3.5.24",
     "@vue/compiler-sfc": "^3.5.24",
     "axios": "^1.13.2",
@@ -46,8 +46,8 @@
     "yaml": "^2.8.1"
   },
   "peerDependencies": {
-    "@endge/raph": "^3.0.10",
-    "@endge/utils": "^0.24.12",
+    "@endge/raph": "^3.0.11",
+    "@endge/utils": "^0.24.13",
     "@primevue/themes": "^4.0.0-rc.1",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",

package/dist/domain/entities/action-flow/REndgeFlow.d.ts

@@ -1,27 +0,0 @@
-import { EndgeFlowDefinition, EndgeFlowNodeDefinition } from '../../types/flow/endge-flow.types';
-declare class REndgeFlowNode {
-    id: string;
-    title: string;
-    blockId: string;
-    kind: EndgeFlowNodeDefinition['kind'];
-    params: Record<string, unknown>;
-    meta: Record<string, unknown>;
-}
-declare class REndgeFlowEdge {
-    id: string;
-    sourceNodeId: string;
-    sourcePortId: string;
-    targetNodeId: string;
-    targetPortId: string;
-    label: string | null;
-}
-export declare class REndgeFlow {
-    version: number;
-    entrypoint: string;
-    nodes: REndgeFlowNode[];
-    edges: REndgeFlowEdge[];
-    static createDefault(): REndgeFlow;
-    static fromPlain(json: Partial<EndgeFlowDefinition>): REndgeFlow;
-    toPlain(): EndgeFlowDefinition;
-}
-export {};

package/dist/domain/types/flow/action.types.d.ts

@@ -1,65 +0,0 @@
-import { ActionRuntimeHostContext } from '../runtime/runtime-host.types';
-import { FlowExecutionState } from './endge-flow-runtime.types';
-import { ActionFlowDefinition } from './endge-flow.types';
-/**
- * Каноническое определение action как flow-графа.
- */
-export type ActionDefinition = ActionFlowDefinition;
-/**
- * Контекст, который получают custom handlers и runtime-step handlers action-flow.
- */
-export interface FlowHandlerContext {
-    /** Каноническое runtime-state текущего запуска flow. */
-    state: FlowExecutionState;
-    /** Идентификатор node внутри flow, если handler вызван из конкретного шага. */
-    nodeId?: string | null;
-    /** Идентификатор block-spec исполненного шага. */
-    blockId?: string | null;
-    /** Identity или id action, с которым связан текущий handler-вызов. */
-    actionId?: string | null;
-    /** runtime-id host или runtime-step, если он известен во время вызова. */
-    runtimeId?: string | null;
-}
-/**
- * Результат работы custom/step handler.
- */
-export type FlowHandlerResult = void | Promise<void>;
-/**
- * Сигнатура обработчика шага runtime-action: получает полный контекст host'а (input, parent, flowState и т.д.),
- * сам извлекает вход из context.input; опционально — flowContext (nodeId, state шага).
- */
-export type ActionStepHandler = (context: ActionRuntimeHostContext, flowContext?: FlowHandlerContext) => FlowHandlerResult;
-/**
- * Проблема, найденная при валидации или исполнении action-flow.
- */
-export interface FlowValidationIssue {
-    /** Машинно-стабильный код проблемы. */
-    code: string;
-    /** Человекочитаемое описание проблемы. */
-    message: string;
-    /** Идентификатор node, если проблема относится к конкретному шагу. */
-    nodeId?: string;
-    /** Идентификатор edge, если проблема относится к конкретной связи. */
-    edgeId?: string;
-}
-/**
- * Скомпилированное action-flow definition с индексами для быстрого исполнения.
- */
-export interface ActionCompiledFlow {
-    /** Нормализованное flow-описание action. */
-    flow: ActionFlowDefinition;
-    /** Индекс node по id. */
-    nodesById: Map<string, ActionFlowDefinition['nodes'][number]>;
-    /** Индекс первого node-id по blockId. */
-    nodeIdByBlockId: Map<string, string>;
-    /** Индекс исходящих ребер по source node id. */
-    outgoingByNodeId: Map<string, ActionFlowDefinition['edges']>;
-    /** Индекс входящих ребер по target node id (для передачи данных с портов). */
-    incomingByNodeId: Map<string, ActionFlowDefinition['edges']>;
-    /** Индекс runtime-step по runtime-id. */
-    runtimeNodeIdByRuntimeId: Map<string, string>;
-    /** Список достижимых node от entrypoint. */
-    reachableNodeIds: string[];
-    /** Validation issues, найденные во время компиляции. */
-    issues: FlowValidationIssue[];
-}

package/dist/domain/types/flow/endge-flow-runtime.types.d.ts

@@ -1,28 +0,0 @@
-import { FlowValidationIssue } from './action.types';
-/**
- * Состояние выполнения action-flow.
- * Это единственный runtime-state flow, который разделяют executor, handlers и runtime-host.
- */
-export interface FlowExecutionState {
-    /** Нормализованный input, с которым был запущен flow. */
-    input: Record<string, unknown>;
-    /** Снимки исполнения шагов, индексированные по node-id. */
-    steps: Record<string, Record<string, unknown>>;
-    /** Локальное изменяемое хранилище flow. */
-    locals: Record<string, unknown>;
-    /** Глобальные runtime-метаданные текущего запуска flow. */
-    globals: Record<string, unknown>;
-    /** Снимок последнего исполненного шага. */
-    lastStep: Record<string, unknown> | null;
-}
-/**
- * Результат исполнения action-flow.
- */
-export interface FlowExecutionResult {
-    /** Удалось ли выполнить flow без validation/runtime issues. */
-    ok: boolean;
-    /** Итоговое состояние выполнения flow. */
-    state: FlowExecutionState;
-    /** Список validation/runtime проблем, обнаруженных при исполнении flow. */
-    issues: FlowValidationIssue[];
-}