@endge/core 1.2.5 → 1.2.8

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

@@ -0,0 +1,147 @@
+import { EntityOrigin, EntityRef } from '../document/entity-management.type';
+export type RuntimeActionId = string;
+export type RuntimeActionSurface = string;
+/** Stable identities of targetless Actions provided by Endge itself. */
+export declare const BUILTIN_ACTION_IDS: {
+    readonly consoleLog: "built-in-console-log";
+    readonly vocabAcquire: "built-in-vocabs-acquire";
+    readonly vocabRefresh: "built-in-vocabs-refresh";
+    readonly vocabInvalidate: "built-in-vocabs-invalidate";
+};
+/** Declarative reference accepted by interactive primitives such as MenuItem. */
+export interface ActionBinding<TInput = unknown> {
+    identity: RuntimeActionId;
+    input?: TInput;
+}
+/** One allowed target shape. Multiple selectors are alternatives. */
+export interface ActionTargetSelector {
+    type: string;
+    identity?: string;
+}
+/** Concrete runtime target. Database ids are intentionally not part of the contract. */
+export interface ActionExecutionTarget<TValue = unknown> {
+    type: string;
+    identity: string;
+    value: TValue;
+}
+/** How an Action is executed when there is no higher-priority runtime binding. */
+export type ActionImplementation = {
+    kind: 'flow';
+} | {
+    kind: 'provider';
+    providerKey: string;
+} | {
+    kind: 'component-port';
+    portName: string;
+};
+export interface ActionDefinitionInput {
+    identity: string;
+    displayName?: string;
+    description?: string | null;
+    active?: boolean;
+    target?: ActionTargetSelector[] | null;
+    input?: unknown;
+    output?: unknown;
+    defaultImplementation?: ActionImplementation;
+    owner?: EntityRef;
+}
+export interface ActionExecuteOptions<TInput = unknown> {
+    input?: TInput;
+    target?: ActionExecutionTarget;
+    context?: Record<string, unknown>;
+    resolution?: Partial<Record<Exclude<ImplementationBindingScope, 'default'>, string>>;
+    providerKey?: string;
+}
+export interface ResolvedActionDescriptor {
+    identity: string;
+    displayName: string;
+    description: string | null;
+    active: boolean;
+    origin: EntityOrigin;
+    /** Runtime catalog placement; it does not affect ownership or persistence. */
+    catalogPath?: string[];
+    owner?: EntityRef;
+    target: ActionTargetSelector[] | null;
+    input: unknown | null;
+    output: unknown | null;
+    defaultImplementation: ActionImplementation;
+    overridden: boolean;
+    effectiveProviderKey: string | null;
+    effectiveProviderOrigin: EntityOrigin | null;
+    bindingScope: ImplementationBindingScope | null;
+}
+export type ImplementationBindingScope = 'default' | 'application' | 'workspace' | 'composition' | 'component' | 'invocation';
+/** Renderer-neutral context passed to a runtime Action provider. */
+export interface RuntimeActionContext {
+    surface: RuntimeActionSurface;
+    runtimeId?: string;
+    target?: unknown;
+}
+/** Callable runtime behavior. Unlike Event, Action has one provider and may return a result. */
+export interface RuntimeAction<TContext extends RuntimeActionContext = RuntimeActionContext, TPayload = unknown, TResult = void> {
+    id: RuntimeActionId;
+    label?: string;
+    description?: string;
+    surface?: RuntimeActionSurface;
+    canExecute?: (context: TContext, payload?: TPayload) => boolean;
+    execute: (context: TContext, payload?: TPayload) => TResult | Promise<TResult>;
+}
+export type AnyRuntimeAction = RuntimeAction<any, any, any>;
+export interface RuntimeActionSnapshotItem {
+    id: RuntimeActionId;
+    label?: string;
+    description?: string;
+    surface?: RuntimeActionSurface;
+}
+export interface RuntimeActionRegistrySnapshot {
+    actions: RuntimeActionSnapshotItem[];
+}
+export type TableColumnPinSide = 'left' | 'right' | 'none';
+export type TableSortDirection = 'asc' | 'desc';
+export type TableSortMode = 'multiple' | 'single' | 'fixed' | 'disabled';
+export declare const TABLE_RUNTIME_ACTION_IDS: {
+    readonly columnHide: "table.column.hide";
+    readonly columnPinLeft: "table.column.pinLeft";
+    readonly columnPinRight: "table.column.pinRight";
+    readonly columnUnpin: "table.column.unpin";
+    readonly columnResetPin: "table.column.resetPin";
+    readonly columnResetAllPins: "table.column.resetAllPins";
+    readonly sortSetColumnAsc: "table.sort.setColumnAsc";
+    readonly sortSetColumnDesc: "table.sort.setColumnDesc";
+    readonly sortClearColumn: "table.sort.clearColumn";
+    readonly sortClearAll: "table.sort.clearAll";
+};
+export type TableRuntimeActionId = typeof TABLE_RUNTIME_ACTION_IDS[keyof typeof TABLE_RUNTIME_ACTION_IDS];
+export interface TableColumnSortState {
+    active: boolean;
+    direction?: TableSortDirection;
+    index?: number;
+}
+/** Operations implemented by one mounted Table instance. */
+export interface TableRuntimeActionTarget {
+    setColumnVisibility?: (columnKey: string, visible: boolean) => void | Promise<void>;
+    setColumnPin?: (columnKey: string, side: TableColumnPinSide) => void | Promise<void>;
+    resetColumnPin?: (columnKey: string) => void | Promise<void>;
+    resetAllPins?: () => void | Promise<void>;
+    setColumnSort?: (columnKey: string, direction: TableSortDirection) => void | Promise<void>;
+    clearColumnSort?: (columnKey: string) => void | Promise<void>;
+    clearAllSort?: () => void | Promise<void>;
+}
+export interface TableColumnActionContext extends RuntimeActionContext {
+    surface: 'table-column-header';
+    tableRuntimeId: string;
+    tableId: string;
+    target: TableRuntimeActionTarget;
+    columnKey: string;
+    columnIndex: number;
+    hideable: boolean;
+    pinnable: boolean;
+    pinMode: 'enabled' | 'disabled';
+    pinState: TableColumnPinSide;
+    defaultPinState: TableColumnPinSide;
+    hasPinChanges: boolean;
+    sortable: boolean;
+    sortMode: TableSortMode;
+    sortState: TableColumnSortState;
+    activeSortCount: number;
+}

package/dist/domain/types/runtime/context-persistence.types.d.ts

@@ -0,0 +1,41 @@
+export type EndgePersistenceDriver = 'local' | 'disabled';
+export interface EndgePersistenceOptions {
+    driver?: EndgePersistenceDriver;
+}
+export interface EndgePersistenceScope {
+    workspaceId: string;
+    tenantId: string;
+    projectId: string;
+    environmentId: string;
+    userId: string;
+}
+export interface EndgeSessionIdentity {
+    userId?: string | null;
+    tenantId?: string | null;
+}
+export interface EndgeSessionIdentityProvider {
+    getCurrentIdentity(): EndgeSessionIdentity | null;
+}
+export interface EndgeStorageAdapter {
+    readonly id: EndgePersistenceDriver;
+    isAvailable(): boolean;
+    read<T>(key: string): T | undefined;
+    write<T>(key: string, value: T): void;
+    remove(key: string): void;
+}
+export interface RuntimeStateDocument {
+    version: 1;
+    scope: EndgePersistenceScope;
+    runtimeId: string;
+    state: Record<string, Record<string, unknown>>;
+}
+export interface RuntimeStateControllerLike {
+    readonly runtimeId: string;
+    readonly storageId: string;
+    readonly storageKey: string;
+    readonly scope: EndgePersistenceScope;
+    get<T>(entityKey: string, section: string, fallback: T): T;
+    set<T>(entityKey: string, section: string, value: T): void;
+    remove(entityKey: string, section?: string): void;
+    clear(): void;
+}

package/dist/domain/types/runtime/implementation.types.d.ts

@@ -0,0 +1,59 @@
+import { EntityOrigin } from '../document/entity-management.type';
+import { ActionExecutionTarget, ActionTargetSelector, ImplementationBindingScope } from './action.types';
+export interface ImplementationContract {
+    target?: ActionTargetSelector[] | null;
+    input?: unknown | null;
+    output?: unknown | null;
+}
+export interface ImplementationExecutableRef {
+    type: string;
+    identity: string;
+    value?: unknown;
+}
+export interface ImplementationInvocation<TInput = unknown> {
+    executable: ImplementationExecutableRef;
+    input?: TInput;
+    target?: ActionExecutionTarget;
+    context?: Record<string, unknown>;
+}
+export interface ImplementationProvider<TInput = unknown, TResult = unknown> {
+    key: string;
+    origin: EntityOrigin;
+    active?: boolean;
+    contract?: ImplementationContract;
+    canExecute?: (invocation: ImplementationInvocation<TInput>) => boolean;
+    execute: (invocation: ImplementationInvocation<TInput>) => TResult | Promise<TResult>;
+}
+export interface ImplementationBinding {
+    executableType: string;
+    executableIdentity: string;
+    providerKey: string;
+    scope: Exclude<ImplementationBindingScope, 'default'>;
+    scopeIdentity?: string;
+    priority?: number;
+}
+export interface ImplementationResolutionRequest {
+    executable: ImplementationExecutableRef;
+    defaultProviderKey: string | null;
+    scopeIdentities?: Partial<Record<Exclude<ImplementationBindingScope, 'default'>, string>>;
+    invocationProviderKey?: string;
+    expectedContract?: ImplementationContract;
+}
+export interface ResolvedImplementation {
+    provider: ImplementationProvider;
+    binding: ImplementationBinding | null;
+    scope: ImplementationBindingScope;
+}
+export interface ImplementationSnapshot {
+    providers: Array<{
+        key: string;
+        active: boolean;
+        origin: EntityOrigin;
+    }>;
+    bindings: ImplementationBinding[];
+}
+export type ImplementationDiagnosticCode = 'implementation-provider-missing' | 'implementation-provider-inactive' | 'implementation-binding-ambiguous' | 'implementation-cannot-execute' | 'implementation-contract-incompatible';
+export declare class ImplementationError extends Error {
+    readonly code: ImplementationDiagnosticCode;
+    constructor(code: ImplementationDiagnosticCode, message: string);
+}

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

@@ -0,0 +1,17 @@
+export * from './action.types';
+export * from './vocab-cache.types';
+export * from './implementation.types';
+export * from './context-persistence.types';
+export * from './query-execution.types';
+export * from './runtime-entity-map.types';
+export * from './runtime-host.types';
+export * from './runtime-execute.type';
+export * from './runtime-registry.types';
+export * from './runtime-resource.types';
+export * from './runtime-scope.types';
+export * from './sfc-render-inspection.type';
+export * from './runtime-project-session.types';
+export * from './runtime-strategy.types';
+export * from './runtime.types';
+export * from './table-binding.types';
+export * from './table.types';

package/dist/domain/types/runtime/query-execution.types.d.ts

@@ -0,0 +1,10 @@
+import { QueryProgramPayload } from '../program/program.types';
+/** Runtime context одного выполнения compiled query artifact. */
+export interface QueryExecutionContext {
+    /** Runtime-ready query payload из Endge.program. */
+    payload: QueryProgramPayload;
+    /** Входные параметры одноразового или реактивного запуска. */
+    vars?: Record<string, unknown>;
+    /** AbortSignal текущего runtime run. */
+    signal?: AbortSignal;
+}

package/dist/domain/types/runtime/runtime-entity-map.types.d.ts

@@ -0,0 +1,31 @@
+import { RAction } from '../../entities/reflect/RAction';
+import { RComponentSFC } from '../../entities/reflect/RComponentSFC';
+import { RPage } from '../../entities/reflect/RPage';
+import { RProject } from '../../entities/reflect/RProject';
+import { RQuery } from '../../entities/reflect/RQuery';
+import { RFilter } from '../../entities/reflect/RFilter';
+import { RComposition } from '../../entities/reflect/RComposition';
+import { RStore } from '../../entities/reflect/RStore';
+/**
+ * Канонический перечень сущностей, для которых может существовать runtime-host.
+ */
+export interface RuntimeEntityModelMap {
+    /** Доменная модель проекта. */
+    project: RProject;
+    /** Доменная модель страницы. */
+    page: RPage;
+    /** Доменная модель SFC-компонента нового API. */
+    'component-sfc': RComponentSFC;
+    /** Доменная модель запроса. */
+    query: RQuery;
+    /** Source-first Filter runtime. */
+    filter: RFilter;
+    /** Runtime orchestration graph. */
+    composition: RComposition;
+    /** Source-first reactive Store runtime. */
+    store: RStore;
+    /** Доменная модель action. */
+    action: RAction;
+}
+/** Дискриминатор типа runtime-сущности. */
+export type RuntimeEntityType = keyof RuntimeEntityModelMap;

package/dist/domain/types/runtime/runtime-execute.type.d.ts

@@ -0,0 +1,27 @@
+import { RuntimeAppScope } from '../../entities/runtime/RuntimeAppScope';
+import { EndgePersistenceDriver } from './context-persistence.types';
+import { RuntimeArtifactReader } from './runtime-host.types';
+import { AnyRuntimeHost } from './runtime-strategy.types';
+/** Допустимая ссылка на зарегистрированный родительский runtime-host. */
+export type RuntimeParentRef = AnyRuntimeHost | string;
+/** Типизированные параметры создания runtime-host. */
+export interface RuntimeExecuteOptions {
+    /** Явный runtime-id вместо автоматически выделенного адреса. */
+    id?: string;
+    /** Локальный id экземпляра внутри app scope. */
+    instanceId?: string;
+    /** Зарегистрированный родительский host или его runtime-id. */
+    parent?: RuntimeParentRef | null;
+    /** App scope или id зарегистрированного app scope. */
+    appScope?: RuntimeAppScope | string;
+    /** Read-only источник compiled artifacts. */
+    artifactReader?: RuntimeArtifactReader;
+    /** Политика persistence для runtime state. */
+    persistence?: EndgePersistenceDriver;
+    /** Стабильный storage-id для persisted runtime state. */
+    persistenceKey?: string;
+    /** Strategy-specific metadata, не участвующая в создании runtime tree. */
+    meta?: Record<string, unknown>;
+}
+/** Параметры запуска host через конкретный app scope. */
+export type RuntimeAppScopeExecuteOptions = Omit<RuntimeExecuteOptions, 'appScope'>;