@raphy-js/raph 1.0.0-dev.2 → 1.0.1-dev.20

package/dist/runtime/RaphRuntime.d.ts

@@ -1,285 +1,225 @@
-import { DataPathDef, PathEvents, PathOptions } from '../path/path.types';
-import { DerivedOptions, RaphDerivedHandle } from '../path/RaphDerivedHandle';
+import { DerivedOptions, RaphDerivedHandle } from '../path/derived/RaphDerivedHandle';
+import { RaphMeta } from '../path/meta/RaphMeta';
+import { DataPathDef, PathOptions } from '../path/path.types';
 import { RaphKernelRoot, RaphKernel } from '../path/RaphKernel';
-import { Disposer, ReadonlySignal, Signal, WatchOptions, WatchSource, WatchValue, WritableComputedOptions } from '../reactivity/types';
-import { DepGraph } from './parent-graph';
-import { FrameLoopLease, RaphEffectOptions, RaphObserveDataOptions, RaphPhase, RaphSchedulerMode, RaphTrackOptions } from './phase.types';
-import { RaphRuntimeDebug } from './RaphDebug';
-import { NodeOptions, RaphNode } from './RaphNode';
-import { RaphMeta } from '../path/RaphMeta';
-import { PathHandle } from './PathHandle';
-import { RaphScope } from './RaphScope';
-import { RuntimeReactivity } from './RuntimeReactivity';
+import { Disposer, ReadonlySignal, Signal, WritableComputedOptions } from '../reactivity/types';
+import { RaphDebugOptions, RaphMachineDebugRegistration, RaphRuntimeDebug, RaphTraceEventInput, RaphTraceKind } from './diagnostics/RaphDebug';
+import { DepGraph } from './ownership/parent-graph.types';
+import { NodeOptions, RaphNode } from './ownership/RaphNode';
+import { FrameLoopLease, RaphAggregateSource, RaphEffectOptions, RaphPhase, RaphPhaseEffect, RaphSchedulerMode, RaphStructureCause, RaphWatchOptions, RaphWatchSource } from './phases/phase.types';
+import { RaphMetaSourceOptions, RaphMetaSource } from './reactivity/RaphMetaSource';
+import { RaphAggregate, RaphWorkGraph } from './reactivity/RaphWorkGraph';
+import { RaphScope } from './ownership/RaphScope';
+import { PathHandle } from './reactivity/PathHandle';
+import { RuntimeReactivity } from './reactivity/RuntimeReactivity';
 export interface RaphRuntimeOptions {
+    readonly adaptiveDependencyIndex?: boolean;
+    readonly debug?: RaphDebugOptions;
     readonly id?: string;
     readonly kernel?: RaphKernel;
     readonly enforceActions?: boolean;
     readonly scheduler?: RaphSchedulerMode;
 }
 export interface RaphRuntimeConfiguration {
+    readonly adaptiveDependencyIndex: boolean;
+    readonly debug?: RaphDebugOptions;
     readonly id: string;
     readonly kernel: RaphKernel;
     readonly enforceActions: boolean;
     readonly scheduler: RaphSchedulerMode;
 }
-/**
- * Один изолированный signal execution-plane поверх собственного или shared Kernel.
- */
+export type RaphRuntimeMeta = Pick<RaphMeta, 'delete' | 'get' | 'has' | 'merge' | 'set'>;
+/** @internal */
+export interface RaphPausableRegistration {
+    readonly dispose: Disposer;
+    readonly pause: () => void;
+    readonly resume: () => void;
+}
+/** Isolated Runtime execution plane with phase-bound work only. */
 export declare class RaphRuntime {
     private static _runtimeCounter;
+    readonly mode: "runtime";
     readonly configuration: RaphRuntimeConfiguration;
     readonly rootScope: RaphScope;
     readonly root: RaphNode;
+    readonly frameTick: ReadonlySignal<number>;
     private readonly _reactivity;
     private readonly _signalLifecycle;
+    private readonly _workGraph;
+    private readonly _frameTickWritable;
+    private readonly _setFrameTick;
     private _pathHandles;
     private _meta;
     private _phases;
     private _frameLoop;
-    private _frameRevision;
-    private _frameRevisionValue;
     private _debug;
+    private readonly _debugController;
     private _parentGraph;
     private readonly _owners;
-    private _transactionDepth;
+    private _batchDepth;
     private _mutationDepth;
-    private _kernelTransactionDepth;
+    private _kernelBatchDepth;
+    private _ownerDisposalDepth;
     private _actionDepth;
+    private _actionCounter;
+    private readonly _traceCauseStack;
+    private _phaseTraceOperations;
     private _executionRequested;
     private _disposed;
     private readonly _disposedListeners;
-    /**
-     * Создаёт изолированный execution graph поверх собственного или shared Kernel.
-     */
     constructor(options?: RaphRuntimeOptions);
-    /**
-     * Возвращает внутренний runtime reactivity adapter.
-     * @internal
-     */
+    /** @internal */
     _getReactivity(): RuntimeReactivity;
     /**
-     * Возвращает стабильный идентификатор runtime.
+     * Возвращает внутренний WorkGraph для optional execution layers.
+     *
+     * @internal
      */
+    _getWorkGraph(): RaphWorkGraph;
     get id(): string;
-    /**
-     * Возвращает data/meta Kernel этого runtime.
-     */
     get kernel(): RaphKernel;
-    /**
-     * Возвращает лениво созданный runtime-owned metadata facade.
-     */
-    get meta(): RaphMeta;
-    /**
-     * Показывает, освобождён ли runtime.
-     */
     get disposed(): boolean;
-    /**
-     * Возвращает лениво созданное read-only представление ownership graph.
-     */
     get graph(): DepGraph;
-    /**
-     * Показывает, удерживается ли автоматический frame-loop.
-     */
     get loopEnabled(): boolean;
-    /**
-     * Возвращает последний frame context runtime pipeline.
-     */
-    get frame(): Readonly<{
-        now: number;
-        delta: number;
-        elapsed: number;
-        frame: number;
-    }>;
-    /**
-     * Возвращает текущее определение runtime phases.
-     */
+    get frame(): import('./phases/phase.types').RaphFrameContext;
     get phases(): readonly RaphPhase[];
-    /**
-     * Формирует диагностический снимок materialized derived registry.
-     */
+    /** Runtime metadata facade intentionally excludes unphased watch(). */
+    get meta(): RaphRuntimeMeta;
     getDerivedSnapshot(): ReturnType<RaphKernel['getDerivedSnapshot']>;
-    /**
-     * Возвращает лениво созданную read-only диагностику runtime и ownership tree.
-     */
     get debug(): RaphRuntimeDebug;
-    /**
-     * Создаёт writable signal, принадлежащий указанному owner.
-     */
     signal<T>(value: T, owner?: RaphScope): Signal<T>;
     /**
-     * Создаёт computed, принадлежащий указанному owner.
+     * Creates a deep reactive Proxy owned by this Runtime root scope.
+     * Property dependencies use the intrusive graph directly and intentionally
+     * do not create per-property WorkGraph producers or phase causes.
      */
+    reactive<T extends object>(value: T): T;
     computed<T>(getter: () => T, owner?: RaphScope): ReadonlySignal<T>;
     computed<T>(options: WritableComputedOptions<T>, owner?: RaphScope): Signal<T>;
-    /**
-     * Создаёт реактивный effect и регистрирует его lifecycle у owner.
-     */
-    effect(callback: () => void | Disposer, owner?: RaphScope): Disposer;
-    effect(phase: string, callback: () => void | Disposer, options?: RaphEffectOptions, owner?: RaphScope): Disposer;
-    /**
-     * Подписывает runtime owner на path- либо signal-изменения.
-     */
-    watch(masks: DataPathDef | readonly DataPathDef[], callback: (payload: PathEvents) => void | Disposer, options?: WatchOptions, owner?: RaphScope): Disposer;
-    watch<S extends WatchSource | readonly WatchSource[]>(source: S, callback: (value: WatchValue<S>, previous: WatchValue<S> | undefined) => void | Disposer, options?: WatchOptions, owner?: RaphScope): Disposer;
-    /**
-     * Возвращает кешируемый runtime-owned handle canonical path.
-     */
+    /** Low-level adapter form. Prefer consumer.effect(). */
+    effect(consumer: RaphScope, phaseInput: string, callback: RaphPhaseEffect, options?: RaphEffectOptions): Disposer;
+    /** @internal */
+    _effectRegistration(consumer: RaphScope, phaseInput: string, callback: RaphPhaseEffect, options?: RaphEffectOptions, startPaused?: boolean): RaphPausableRegistration;
+    /** Low-level adapter form. Prefer consumer.watch(). */
+    watch(consumer: RaphScope, source: RaphWatchSource, phaseInput: string, callback: RaphPhaseEffect, options?: RaphWatchOptions): Disposer;
+    /** @internal */
+    _watchRegistration(consumer: RaphScope, source: RaphWatchSource, phaseInput: string, callback: RaphPhaseEffect, options?: RaphWatchOptions, startPaused?: boolean): RaphPausableRegistration;
+    aggregate(consumer: RaphScope, sources: readonly RaphAggregateSource[]): RaphAggregate;
+    /** Creates a lazy root-owned metadata event source for phase watches. */
+    metaSource(masks: DataPathDef | readonly DataPathDef[], options?: RaphMetaSourceOptions): RaphMetaSource;
     path<T>(path: DataPathDef, options?: PathOptions): PathHandle<T>;
-    /**
-     * Возвращает весь path-root Kernel с обычным tracking чтения.
-     */
     get<T = RaphKernelRoot>(): T | undefined;
-    /**
-     * Возвращает значение Kernel по пути с runtime lifecycle checks.
-     */
     get<T = unknown>(path: DataPathDef, options?: PathOptions): T | undefined;
-    /**
-     * Читает весь path-root Kernel без регистрации реактивной зависимости.
-     */
     peek<T = RaphKernelRoot>(): T | undefined;
-    /**
-     * Читает значение Kernel без регистрации реактивной зависимости.
-     */
     peek<T = unknown>(path: DataPathDef, options?: PathOptions): T | undefined;
-    /**
-     * Проверяет наличие значения Kernel по пути.
-     */
     has(path: DataPathDef, options?: PathOptions): boolean;
-    /**
-     * Записывает значение Kernel внутри runtime write policy.
-     */
     set<T>(path: DataPathDef, value: T, options?: PathOptions): void;
-    /**
-     * Объединяет значение Kernel внутри runtime write policy.
-     */
     merge(path: DataPathDef, value: unknown, options?: PathOptions): void;
-    /**
-     * Удаляет значение Kernel внутри runtime write policy.
-     */
     delete(path: DataPathDef, options?: PathOptions): void;
-    /**
-     * Выполняет операцию в общей синхронной transaction boundary.
-     */
-    transaction<T>(operation: () => T): T;
-    /**
-     * Создаёт именованную action boundary для разрешённых записей.
-     */
+    batch<T>(operation: () => T): T;
+    /** Batches an internal reactive-only commit without opening an unused Kernel boundary. @internal */
+    _batchReactive<T>(operation: () => T): T;
+    private _batch;
+    action<Args extends unknown[], Result>(operation: (...args: Args) => Result, owner?: RaphScope): (...args: Args) => Result;
     action<Args extends unknown[], Result>(name: string, operation: (...args: Args) => Result, owner?: RaphScope): (...args: Args) => Result;
-    /**
-     * Выполняет операцию внутри action boundary.
-     */
-    runInAction<T>(_name: string, operation: () => T): T;
-    /**
-     * Выполняет операцию без регистрации реактивных зависимостей.
-     */
     untracked<T>(operation: () => T): T;
-    /**
-     * Создаёт дочерний lifecycle scope.
-     */
     scope(id: string): RaphScope;
-    /**
-     * Создаёт дочерний execution node.
-     */
-    node<TApi>(options: NodeOptions, setup: (node: RaphNode) => TApi): RaphNode<TApi>;
-    /**
-     * Находит принадлежащий runtime node по id для диагностики.
-     */
+    node<TApi = void>(options: NodeOptions, setup?: (node: RaphNode) => TApi): RaphNode<TApi>;
     getNode(id: string): RaphNode | undefined;
-    /**
-     * Заменяет полное определение phase pipeline до его первого выполнения.
-     */
     definePhases(phases: readonly RaphPhase[]): void;
-    /**
-     * Добавляет phase до первого выполнения pipeline.
-     */
     addPhase(phase: RaphPhase): void;
-    /**
-     * Удаляет пользовательские phases до первого выполнения pipeline.
-     */
     clearPhases(): void;
-    /**
-     * Регистрирует path observer в phase pipeline.
-     */
-    observeData(node: RaphNode, masks: DataPathDef | readonly DataPathDef[], options: RaphObserveDataOptions): Disposer;
-    /**
-     * Регистрирует tracked executor указанной phase.
-     */
-    track(node: RaphNode, masks: DataPathDef | readonly DataPathDef[], options?: RaphTrackOptions): Disposer;
-    /**
-     * Помечает node для выполнения в pipeline.
-     */
-    invalidateNode(node: RaphNode, phase: string): void;
-    /**
-     * Синхронно выполняет все готовые очереди pipeline.
-     */
+    requestExecution(): void;
     flush(): void;
-    /**
-     * Получает lease автоматического frame-loop.
-     */
+    afterFlush(): Promise<void>;
     acquireLoop(owner: string): FrameLoopLease;
-    /**
-     * Запускает manual lease автоматического frame-loop.
-     */
     startLoop(): void;
-    /**
-     * Останавливает manual lease автоматического frame-loop.
-     */
     stopLoop(): void;
-    /**
-     * Создаёт управляемое derived-представление source path в target path.
-     */
     derive<TSource, TTarget>(options: DerivedOptions<TSource, TTarget>): RaphDerivedHandle<TSource, TTarget>;
+    dispose(): void;
+    /** @internal */
+    _onDisposed(listener: () => void): Disposer;
+    /** @internal */
+    _notifyNodeStructure(node: RaphNode, structure: RaphStructureCause, oldAncestors: readonly RaphNode[], newAncestors: readonly RaphNode[]): void;
+    /** @internal */
+    _notifyNodeTouch(node: RaphNode, metadata?: unknown): void;
+    /** @internal */
+    _assertNodeReparentAllowed(node: RaphNode, newParent: RaphNode): void;
+    /** @internal */
+    _releaseNode(node: RaphNode): void;
+    /** @internal */
+    _runNodeMutation<T>(operation: () => T): T;
+    /** @internal */
+    _runPhaseTransition<T>(operation: () => T): T;
+    /** @internal */
+    _beginOwnerDisposal(): void;
+    /** @internal */
+    _endOwnerDisposal(): void;
+    /** @internal */
+    _ownerDisposalActive(): boolean;
+    /** @internal */
+    _registerOwner(owner: RaphScope): void;
+    /** @internal */
+    _unregisterOwner(owner: RaphScope): void;
+    /** @internal */
+    _assertOwnerRuntime(owner: RaphScope): void;
+    /** @internal */
+    _beginKernelBatch(): void;
+    /** @internal */
+    _endKernelBatch(): void;
+    /** Регистрирует read-only diagnostics projection optional Machine. @internal */
+    _registerMachineDebug(registration: RaphMachineDebugRegistration): Disposer;
+    /**
+     * Проверяет optional diagnostic identity без создания public facade.
+     *
+     * @internal
+     */
+    _hasMachineDebug(id: string): boolean;
     /**
-     * Освобождает execution graph и отсоединяет runtime от shared Kernel.
+     * Проверяет optional trace path без выделения operation ID.
+     *
+     * @internal
      */
-    dispose(): void;
+    _traces(kind: RaphTraceKind): boolean;
+    /** Возвращает наследуемый cause для optional execution layers. @internal */
+    _currentTraceCauseId(): number | undefined;
+    /** Выдаёт operation id только на активном trace path. @internal */
+    _nextTraceOperation(kind: RaphTraceKind): number | undefined;
     /**
-     * Регистрирует listener освобождения runtime.
+     * Проверяет, должен ли untracked work изолировать reactive или Runtime owner context.
+     *
      * @internal
      */
-    _onDisposed(listener: () => void): Disposer;
-    private _watchPath;
+    _hasActiveReactiveContext(): boolean;
+    /** Записывает optional trace event без machine dependency. @internal */
+    _recordTrace(event: RaphTraceEventInput): void;
+    /** Наследует cause через outputs/tasks optional execution layers. @internal */
+    _runWithTraceCause<T>(causeId: number | undefined, operation: () => T): T;
+    private _validatePhaseBinding;
     private _createDebugSnapshot;
-    private _watchMeta;
-    private _watchMetaInPhase;
+    private _createDebugTree;
+    private _createDebugStats;
     private _releasePathHandle;
     private get _execution();
     private get _clock();
     private _tickFrameLoop;
     private _attachWritableComputed;
     private _own;
-    /**
-     * Регистрирует lifecycle owner в runtime registry.
-     * @internal
-     */
-    _registerOwner(owner: RaphScope): void;
-    /**
-     * Удаляет lifecycle owner из runtime registry.
-     * @internal
-     */
-    _unregisterOwner(owner: RaphScope): void;
-    /**
-     * Проверяет, что owner принадлежит этому живому runtime.
-     * @internal
-     */
-    _assertOwnerRuntime(owner: RaphScope): void;
     private _runTracked;
     private _runUntracked;
     private _runWrite;
+    private _finishExecutionBoundary;
+    private _clearTransientCausesIfSettled;
     private _requestExecution;
+    private _assertTrackedRead;
     /**
-     * Открывает shared Kernel transaction для runtime.
-     * @internal
-     */
-    _beginKernelTransaction(): void;
-    /**
-     * Закрывает shared Kernel transaction и запускает отложенное выполнение.
+     * Проверяет tracked read из optional owned source.
+     *
      * @internal
      */
-    _endKernelTransaction(): void;
-    private _assertTrackedRead;
+    _assertSourceReadable(owner: RaphScope): void;
+    private _assertImplicitDependency;
     private _assertWriteAllowed;
     private _throwCrossRuntime;
-    private _throwDisposed;
     private _assertAlive;
 }

package/dist/runtime/diagnostics/RaphDebug.d.ts

@@ -0,0 +1,239 @@
+import { Disposer } from '../../reactivity/types';
+import { RaphScope } from '../ownership/RaphScope';
+export type RaphTraceKind = 'action' | 'error' | 'machine' | 'phase';
+export type RaphTraceGuardMode = 'all' | 'failed' | 'none';
+export type RaphTraceContextMode = 'keys' | 'none';
+export interface RaphTraceOptions {
+    readonly capacity?: number;
+    readonly context?: RaphTraceContextMode;
+    readonly guards?: RaphTraceGuardMode;
+    readonly include?: readonly RaphTraceKind[];
+}
+export interface RaphDebugOptions {
+    readonly trace?: false | RaphTraceOptions;
+}
+export interface RaphTraceEventInput {
+    readonly causeId?: number;
+    readonly context?: Readonly<Record<string, unknown>>;
+    readonly details?: Readonly<Record<string, unknown>>;
+    readonly guard?: 'failed' | 'passed';
+    readonly kind: RaphTraceKind;
+    readonly name: string;
+    readonly operationId?: number;
+    readonly status?: 'end' | 'error' | 'ignored' | 'start';
+}
+export interface RaphTraceEvent {
+    readonly causeId?: number;
+    readonly contextKeys?: readonly string[];
+    readonly details?: Readonly<Record<string, unknown>>;
+    readonly guard?: 'failed' | 'passed';
+    readonly kind: RaphTraceKind;
+    readonly name: string;
+    readonly operationId?: number;
+    readonly sequence: number;
+    readonly status?: 'end' | 'error' | 'ignored' | 'start';
+    readonly timestamp: number;
+}
+export interface RaphTraceReadOptions {
+    readonly limit?: number;
+    readonly since?: number;
+}
+export interface RaphTraceStatus {
+    readonly capacity: number;
+    readonly context: RaphTraceContextMode;
+    readonly enabled: boolean;
+    readonly guards: RaphTraceGuardMode;
+    readonly include: readonly RaphTraceKind[];
+    readonly size: number;
+}
+export interface RaphDebugTraceApi {
+    clear: () => void;
+    read: (options?: RaphTraceReadOptions) => readonly RaphTraceEvent[];
+    start: (options?: RaphTraceOptions) => void;
+    status: () => RaphTraceStatus;
+    stop: () => void;
+}
+export interface RaphMachineDebugSnapshot {
+    readonly active: readonly string[];
+    readonly contextKeys: readonly string[];
+    readonly id: string;
+    readonly modelId: string;
+    readonly meta: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+    readonly ownerId: string;
+    readonly parentId?: string;
+    readonly revision: number;
+    readonly status: string;
+    readonly actors: readonly string[];
+}
+export interface RaphMachineDebugSummary {
+    readonly active: readonly string[];
+    readonly id: string;
+    readonly modelId: string;
+    readonly ownerId: string;
+    readonly parentId?: string;
+    readonly revision: number;
+    readonly status: string;
+}
+/** @internal */
+export interface RaphMachineDebugRegistration {
+    readonly id: string;
+    readonly ownerId: string;
+    readonly parentId?: string;
+    readonly snapshot: () => RaphMachineDebugSnapshot;
+}
+export interface RaphDebugMachinesApi {
+    list: () => readonly RaphMachineDebugSummary[];
+    snapshot: (id: string) => RaphMachineDebugSnapshot | undefined;
+}
+export interface RaphDebugOwnerSnapshot {
+    readonly children: readonly RaphDebugOwnerSnapshot[];
+    readonly disposed: boolean;
+    readonly id: string;
+    readonly kind: 'node' | 'scope';
+    readonly resources: number;
+    readonly sources: number;
+}
+export interface RaphDebugFrameLoopSnapshot {
+    readonly leases: number;
+    readonly manual: boolean;
+    readonly running: boolean;
+}
+export interface RaphDebugSnapshot {
+    readonly actionDepth: number;
+    readonly batchDepth: number;
+    readonly disposed: boolean;
+    readonly frameLoop: RaphDebugFrameLoopSnapshot;
+    readonly id: string;
+    readonly kernelBatchDepth: number;
+    readonly machines: number;
+    readonly owners: number;
+    readonly pathHandles: number;
+    readonly pending: boolean;
+    readonly root: RaphDebugOwnerSnapshot;
+    readonly rootScope: RaphDebugOwnerSnapshot;
+    readonly scopes: readonly RaphDebugOwnerSnapshot[];
+    readonly traceEvents: number;
+}
+export interface RaphDebugTreeNode {
+    readonly children: readonly RaphDebugTreeNode[];
+    readonly count?: number;
+    readonly disposed?: boolean;
+    readonly id: string;
+    readonly kind: 'actor' | 'machine' | 'node' | 'resource' | 'runtime' | 'scope';
+    readonly status?: string;
+}
+export interface RaphDebugStats {
+    readonly actors: number;
+    readonly machines: number;
+    readonly nodes: number;
+    readonly owners: number;
+    readonly pathHandles: number;
+    readonly pending: boolean;
+    readonly resources: number;
+    readonly scopes: number;
+    readonly sources: number;
+    readonly traceEvents: number;
+}
+export interface RaphRuntimeDebug {
+    readonly machines: RaphDebugMachinesApi;
+    readonly trace: RaphDebugTraceApi;
+    getTree: () => RaphDebugTreeNode;
+    snapshot: () => RaphDebugSnapshot;
+    stats: () => RaphDebugStats;
+}
+/**
+ * Хранит opt-in trace и ленивый registry machine diagnostics одного Runtime.
+ * @internal
+ */
+export declare class RaphDebugController {
+    private _capacity;
+    private _context;
+    private _guards;
+    private _include;
+    private _enabled;
+    private _events;
+    private _eventStart;
+    private _eventSize;
+    private _sequence;
+    private _operationSequence;
+    private _machines;
+    readonly trace: RaphDebugTraceApi;
+    readonly machines: RaphDebugMachinesApi;
+    /**
+     * Создаёт controller; ring buffer появляется только при включённом trace.
+     */
+    constructor(options?: RaphDebugOptions);
+    /**
+     * Включает trace с текущими или явно переданными настройками.
+     */
+    start(options?: RaphTraceOptions): void;
+    /**
+     * Останавливает запись, сохраняя уже накопленные events.
+     */
+    stop(): void;
+    /**
+     * Удаляет все накопленные events, не меняя status trace.
+     */
+    clear(): void;
+    /**
+     * Формирует immutable chronological copy ring buffer.
+     */
+    read(options?: RaphTraceReadOptions): readonly RaphTraceEvent[];
+    /**
+     * Возвращает текущую конфигурацию и заполнение buffer.
+     */
+    status(): RaphTraceStatus;
+    /**
+     * Выделяет operation ID только когда trace активен для этого kind.
+     * @internal
+     */
+    nextOperationId(kind: RaphTraceKind): number | undefined;
+    /**
+     * Проверяет active trace path без выделения operation ID.
+     *
+     * @internal
+     */
+    traces(kind: RaphTraceKind): boolean;
+    /**
+     * Записывает одно событие без allocations/timestamp на disabled path.
+     * @internal
+     */
+    record(input: RaphTraceEventInput): void;
+    /**
+     * Регистрирует read-only machine projection без импорта machine engine в Runtime.
+     * @internal
+     */
+    registerMachine(registration: RaphMachineDebugRegistration): Disposer;
+    /**
+     * Проверяет diagnostic identity без создания public snapshot.
+     *
+     * @internal
+     */
+    hasMachine(id: string): boolean;
+    /**
+     * Возвращает compact machine summaries без выполнения guards.
+     */
+    listMachines(): readonly RaphMachineDebugSummary[];
+    /**
+     * Читает готовый machine snapshot; transition selection и guards не вызываются.
+     */
+    machineSnapshot(id: string): RaphMachineDebugSnapshot | undefined;
+    /**
+     * Возвращает число зарегистрированных machines.
+     * @internal
+     */
+    get machineCount(): number;
+    /**
+     * Возвращает число текущих trace events.
+     * @internal
+     */
+    get traceSize(): number;
+    /** Возвращает число child actors по уже готовым snapshots. @internal */
+    get actorCount(): number;
+    /** Группирует machine/actor ветви по фактическому lifecycle owner. @internal */
+    machineTreeNodesByOwner(): ReadonlyMap<string, readonly RaphDebugTreeNode[]>;
+    private _applyOptions;
+    private _ensureBuffer;
+}
+export declare function createOwnerSnapshot(owner: RaphScope): RaphDebugOwnerSnapshot;
+export declare function createOwnerTree(owner: RaphScope, machinesByOwner?: ReadonlyMap<string, readonly RaphDebugTreeNode[]>): RaphDebugTreeNode;

package/dist/runtime/errors.d.ts

@@ -14,3 +14,8 @@ export declare class RaphDisposedError extends RaphError {
  */
 export declare class RaphCrossRuntimeError extends RaphError {
 }
+/**
+ * Сообщает об ошибке пользовательского phase processor или task resolution.
+ */
+export declare class RaphPhaseProcessError extends RaphError {
+}