@raphy-js/raph 1.0.1-dev.25 → 1.0.1-dev.54

package/dist/runtime/RaphRuntime.d.ts

@@ -1,19 +1,13 @@
-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, 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, RaphEffectGroupOptions, RaphEffectGroupSlot, RaphEffectInitialMode, RaphEffectOptions, RaphPhase, RaphPhaseEffect, RaphSchedulerMode, RaphStructureCause, RaphWatchOptions, RaphWatchSource } from './phases/phase.types';
-import { RaphPhaseTaskRecord } from './phases/RaphPhaseTaskRecord';
-import { RaphMetaSourceOptions, RaphMetaSource } from './reactivity/RaphMetaSource';
-import { RaphAggregate, RaphWorkGraph } from './reactivity/RaphWorkGraph';
-import { RuntimeDisposalSweeper } from './reactivity/runtime-reactivity.types';
-import { RaphScope } from './ownership/RaphScope';
-import { PathHandle } from './reactivity/PathHandle';
-import { RuntimeReactivity } from './reactivity/RuntimeReactivity';
+import { DerivedOptions, RaphDerivedHandle } from '../path/derived/RaphDerivedHandle.js';
+import { RaphMeta } from '../path/meta/RaphMeta.js';
+import { DataPathDef, PathOptions } from '../path/path.types.js';
+import { RaphKernelRoot, RaphKernel } from '../path/RaphKernel.js';
+import { RaphDebugOptions, RaphRuntimeDebug, RaphDebugController } from './diagnostics/RaphDebug.js';
+import { RaphSchedulerMode } from './phases/phase.types.js';
+import { RaphMetaSourceOptions, RaphMetaSource } from './reactivity/RaphMetaSource.js';
+import { RaphRuntimeBase } from './RaphRuntimeBase.js';
+import { PathHandle } from './reactivity/PathHandle.js';
+export type { RaphPausableRegistration } from './RaphRuntimeBase.js';
 export interface RaphRuntimeOptions {
     readonly adaptiveDependencyIndex?: boolean;
     readonly debug?: RaphDebugOptions;
@@ -31,146 +25,19 @@ export interface RaphRuntimeConfiguration {
     readonly scheduler: RaphSchedulerMode;
 }
 export type RaphRuntimeMeta = Pick<RaphMeta, 'delete' | 'get' | 'has' | 'merge' | 'set'>;
-/**
- * Один phase binding в том виде, в котором его видит effect scope. Регистрацией
- * является сама постоянная запись binding, поэтому её capabilities вызываются
- * только с регистрацией в качестве receiver.
- *
- * @internal
- */
-export interface RaphPausableRegistration {
-    readonly active: boolean;
-    readonly dispose: (this: RaphPausableRegistration) => void;
-    readonly pause: (this: RaphPausableRegistration) => void;
-    readonly resume: (this: RaphPausableRegistration) => void;
-}
-/** Isolated Runtime execution plane with phase-bound work only. */
-export declare class RaphRuntime {
-    private static _runtimeCounter;
-    readonly mode: "runtime";
+export declare class RaphRuntime extends RaphRuntimeBase<RaphRuntime> {
+    readonly reactiveObjects: true;
+    readonly selectors: true;
     readonly configuration: RaphRuntimeConfiguration;
-    readonly rootScope: RaphScope;
-    readonly root: RaphNode;
-    readonly frameTick: ReadonlySignal<number>;
-    private readonly _reactivity;
-    private readonly _signalLifecycle;
-    private readonly _workGraph;
-    private readonly _frameTickSignal;
+    protected readonly _debugController: RaphDebugController;
+    constructor(options?: RaphRuntimeOptions);
     private _pathHandles;
     private _meta;
-    private _phases;
-    private _frameLoop;
     private _debug;
-    private readonly _debugController;
-    private _parentGraph;
-    private readonly _topOwners;
-    private _ownerRegistrations;
-    private _ownersReleased;
-    private _batchDepth;
-    private _mutationDepth;
-    private _kernelBatchDepth;
-    private _ownerDisposalDepth;
-    private readonly _disposingNodes;
-    private _ownerDisposals;
-    private _disposalSweepers;
-    private _nextDisposalSweep;
-    private _actionDepth;
-    private _actionCounter;
-    private readonly _traceCauseStack;
-    private _phaseTraceOperations;
-    private _executionRequested;
-    private _disposed;
-    private readonly _disposedListeners;
-    constructor(options?: RaphRuntimeOptions);
-    /** @internal */
-    _getReactivity(): RuntimeReactivity;
-    /**
-     * Возвращает внутренний WorkGraph для optional execution layers.
-     *
-     * @internal
-     */
-    _getWorkGraph(): RaphWorkGraph;
-    get id(): string;
     get kernel(): RaphKernel;
-    get disposed(): boolean;
-    get graph(): DepGraph;
-    get loopEnabled(): boolean;
-    get frame(): import('./phases/phase.types').RaphFrameContext;
-    get phases(): readonly RaphPhase[];
-    /** Runtime metadata facade intentionally excludes unphased watch(). */
     get meta(): RaphRuntimeMeta;
     getDerivedSnapshot(): ReturnType<RaphKernel['getDerivedSnapshot']>;
     get debug(): RaphRuntimeDebug;
-    signal<T>(value: T, owner?: RaphScope): Signal<T>;
-    /**
-     * 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>;
-    /** Low-level adapter form. Prefer consumer.effect(). */
-    effect(consumer: RaphScope, phaseInput: string, callback: RaphPhaseEffect, options?: RaphEffectOptions): Disposer;
-    /**
-     * Регистрирует один implicit phase effect. Возвращаемая регистрация является
-     * записью binding: она одновременно ресурс владельца, задача engine и элемент
-     * очереди pipeline, поэтому на effect больше ничего не выделяется. Тело
-     * записи engine у всех bindings графа одно — `RuntimeReactivity._phaseBody`:
-     * свой binding оно находит через engine, а не через собственную closure.
-     *
-     * При `taskless` тело вызывается без task: запись получает `TASK_TASKLESS`,
-     * общее тело не читает `record.task`, и frozen facade этого binding не
-     * создаётся, пока его не запросит `process` своей phase. Режим — бит поля
-     * `state`: запись от него не растёт.
-     *
-     * @internal
-     */
-    _effectRegistration(consumer: RaphScope, phaseInput: string, callback: RaphPhaseEffect, options?: RaphEffectOptions, startPaused?: boolean, taskless?: boolean, onExecutionFailure?: (error: unknown) => never, isExecutionCancelled?: () => boolean): RaphPausableRegistration;
-    /**
-     * Регистрирует группу из `count` implicit phase effects на одной записи
-     * binding. Каждый slot получает собственную запись графа engine, то есть
-     * собственный набор зависимостей и собственный признак invalidation, а
-     * запись binding и её место в очереди phase и в списке ресурсов владельца у
-     * группы одни. Тело записи engine у slots то же, что у всех bindings графа.
-     * Возвращаемая регистрация — эта запись; она же handle группы.
-     *
-     * Регистрация ничего не исполняет: каждый slot запускает `_startGroupSlot`.
-     * Запись входит в список владельца сразу, поэтому владелец освобождает
-     * группу после ресурсов, которые зарегистрируют тела её slots.
-     *
-     * @internal
-     */
-    _effectGroupRegistration(consumer: RaphScope, phaseInput: string, count: number, runSlot: RaphEffectGroupSlot, context: unknown, options?: RaphEffectGroupOptions, startPaused?: boolean): RaphPhaseTaskRecord;
-    /**
-     * Запускает один slot группы: планирует его запись графа, ставит запись
-     * группы в очередь и, при `initial: 'sync'`, выполняет flush. Шаги те же, что
-     * у регистрации одиночного implicit effect после создания его записи.
-     *
-     * Сбой внутри вызова останавливает только этот slot и бросается вызывающему,
-     * как сбой первой доставки откатывает регистрацию одиночного binding; группа
-     * и остальные её slots остаются. Группа, у которой остановлен последний slot,
-     * освобождается.
-     *
-     * Запуск на освобождённом владельце бросает `RaphDisposedError`, как
-     * `bindEffect()`: и когда владелец освобождён до вызова, и когда его
-     * освободила первая доставка внутри вызова, при любом scheduler. Молчит
-     * только запуск slot группы, освобождённой при живом владельце.
-     *
-     * @internal
-     */
-    _startGroupSlot(record: RaphPhaseTaskRecord, slot: number, initial: RaphEffectInitialMode, onExecutionFailure?: (error: unknown) => never): void;
-    /** Low-level adapter form. Prefer consumer.watch(). */
-    watch(consumer: RaphScope, source: RaphWatchSource, phaseInput: string, callback: RaphPhaseEffect, options?: RaphWatchOptions): Disposer;
-    /**
-     * Регистрирует один explicit phase watch. Возвращаемая запись binding является
-     * pausable-регистрацией и одновременно ресурсом владельца этого watch.
-     *
-     * @internal
-     */
-    _watchRegistration(consumer: RaphScope, source: RaphWatchSource, phaseInput: string, callback: RaphPhaseEffect, options?: RaphWatchOptions, startPaused?: boolean, onExecutionFailure?: (error: unknown) => never, isExecutionCancelled?: () => boolean): RaphPhaseTaskRecord;
-    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>;
     get<T = RaphKernelRoot>(): T | undefined;
@@ -181,264 +48,13 @@ export declare class RaphRuntime {
     set<T>(path: DataPathDef, value: T, options?: PathOptions): void;
     merge(path: DataPathDef, value: unknown, options?: PathOptions): void;
     delete(path: DataPathDef, options?: PathOptions): void;
-    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;
-    /**
-     * Закрывает один уровень batch: внешний уровень очищает transient causes и
-     * запускает фазы. Бросает ошибку операции, ошибки закрытия либо все вместе;
-     * после успешной операции и закрытия возвращает управление.
-     */
-    private _closeBatch;
-    /**
-     * Исполняет тело action: `batch(() => _runUntracked(() => operation(...args)))`
-     * без closures и без промежуточных вызовов слоёв. Runtime, который один
-     * владеет своим Kernel без derived handles, metadata watchers и adapter,
-     * открывает границы reactive batch, Kernel и path batch явными вызовами и
-     * закрывает их в том же порядке и с теми же ошибками, что вложенные
-     * `batch()` этих слоёв. В любом другом состоянии исполняется сам `batch()`.
-     */
-    private _applyBatch;
-    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;
-    untracked<T>(operation: () => T): T;
-    scope(id: string): RaphScope;
-    node<TApi = void>(options: NodeOptions, setup?: (node: RaphNode) => TApi): RaphNode<TApi>;
-    /**
-     * Создаёт provisional node, выполняет setup и публикует результат; при ошибке
-     * setup откатывает node до выхода из границы mutation.
-     */
-    private _createCommittedNode;
-    getNode(id: string): RaphNode | undefined;
-    definePhases(phases: readonly RaphPhase[]): void;
-    addPhase(phase: RaphPhase): void;
-    clearPhases(): void;
-    requestExecution(): void;
-    flush(): void;
-    afterFlush(): Promise<void>;
-    acquireLoop(owner: string): FrameLoopLease;
-    startLoop(): void;
-    stopLoop(): void;
     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;
-    /**
-     * Сообщает, может ли structural publication этой node дойти до подписчика;
-     * `false` позволяет не строить structure cause и списки ancestors.
-     *
-     * @internal
-     */
-    _hasNodeStructureDemand(node: RaphNode): boolean;
-    /**
-     * Сообщает, есть ли у Runtime хотя бы один подписчик на node: runtime-,
-     * subtree- или self-watcher. Пока он есть, node поддерживает выданный массив
-     * детей на месте, потому что structure cause берёт из него индексы.
-     *
-     * @internal
-     */
-    _hasNodeSubscribers(): boolean;
-    /** @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;
-    /**
-     * Выполняет границу пустой node mutation без аллокаций: эквивалент
-     * `_runWrite(noop)` с тем же запросом исполнения и flush на внешней границе.
-     *
-     * @internal
-     */
-    _touchMutationBoundary(): void;
-    /** @internal */
-    _runPhaseTransition<T>(operation: () => T): T;
-    /**
-     * Открывает границу освобождения. `node` передаёт только dispose самой node:
-     * Runtime помнит её до парного `_endOwnerDisposal`.
-     *
-     * @internal
-     */
-    _beginOwnerDisposal(node?: RaphNode): void;
-    /** @internal */
-    _endOwnerDisposal(): void;
-    /**
-     * Возвращает число владельцев, освобождённых этим Runtime за всё время.
-     *
-     * @internal
-     */
-    _ownerDisposalCount(): number;
-    /**
-     * Подключает участника уборки: Runtime вызовет его на первой внешней границе
-     * освобождения, к которой число освобождённых владельцев достигнет `due`.
-     * Подключённый участник остаётся в очереди, пока сам не откажется от
-     * следующего срока либо не будет отключён.
-     *
-     * @internal
-     */
-    _addDisposalSweeper(sweeper: RuntimeDisposalSweeper, due: number): void;
-    /**
-     * Отключает участника уборки; отключение неизвестного участника безопасно.
-     *
-     * @internal
-     */
-    _removeDisposalSweeper(sweeper: RuntimeDisposalSweeper): void;
-    /**
-     * Вызывает участников уборки, чей срок подошёл, и назначает ближайший
-     * следующий срок. Участник, чей срок не подошёл, вызова не получает:
-     * освобождение владельца стоит участникам работы, только когда подходит их
-     * собственный срок.
-     */
-    private _sweepAfterDisposals;
-    /** @internal */
-    _ownerDisposalActive(): boolean;
-    /**
-     * Учитывает нового владельца и возвращает его порядковый номер регистрации.
-     * Plain scope сразу входит в набор владельцев вне списков детей; node входит
-     * в него сама через `_addTopOwner`, и только если у неё нет parent.
-     *
-     * @internal
-     */
-    _registerOwner(owner: RaphScope): number;
-    /**
-     * Снимает владельца с учёта. Plain scope выходит и из набора владельцев вне
-     * списков детей; node без parent выходит из него сама через
-     * `_removeTopOwner`, а node с parent в нём не состоит.
-     *
-     * @internal
-     */
-    _unregisterOwner(owner: RaphScope): void;
-    /**
-     * Вносит node без parent в набор владельцев вне списков детей.
-     *
-     * @internal
-     */
-    _addTopOwner(node: RaphNode): void;
-    /**
-     * Убирает node из набора владельцев вне списков детей: она освобождена либо
-     * получила parent. Повторный вызов и вызов после освобождения Runtime
-     * безопасны.
-     *
-     * @internal
-     */
-    _removeTopOwner(node: RaphNode): 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;
-    /**
-     * Проверяет optional trace path без выделения operation ID.
-     *
-     * @internal
-     */
-    _traces(kind: RaphTraceKind): boolean;
-    /** Возвращает наследуемый cause для optional execution layers. @internal */
-    _currentTraceCauseId(): number | undefined;
-    /** Выдаёт operation id только на активном trace path. @internal */
-    _nextTraceOperation(kind: RaphTraceKind): number | undefined;
-    /**
-     * Проверяет, должен ли untracked work изолировать reactive или Runtime owner context.
-     *
-     * @internal
-     */
-    _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;
-    /**
-     * Выполняет единственную проверку binding: pipeline доверяет её результату.
-     */
-    private _validatePhaseBinding;
-    /**
-     * Освобождает binding, регистрация которого не удалась, и повторно бросает
-     * причину сбоя; ошибка самого освобождения присоединяется к ней.
-     */
-    private _rollbackRegistration;
     private _createDebugSnapshot;
     private _createDebugTree;
     private _createDebugStats;
-    /**
-     * Возвращает число владельцев, которых Runtime числит живыми: зарегистрированных
-     * и ещё не снятых с учёта. После освобождения Runtime их нет.
-     */
-    private _liveOwnerCount;
-    /**
-     * Собирает всех владельцев, которых Runtime числит живыми. Владельцы вне
-     * списков детей идут в порядке регистрации, каждый — вместе с потомками по
-     * спискам детей. Node, чей dispose ещё исполняется, из списка parent уже
-     * вышла либо потеряла parent, который сбросил свой список: её и оставшихся
-     * у неё детей добавляют места границ освобождения.
-     */
-    private _collectOwners;
     private _releasePathHandle;
-    private get _execution();
-    private get _clock();
-    private _tickFrameLoop;
-    /**
-     * Записывает frame signal в собственной границе записи, минуя политику
-     * actions: кадр продвигает сам Runtime.
-     */
-    private _setFrameTick;
-    private _attachWritableComputed;
-    private _own;
-    private _runTracked;
-    private _runUntracked;
-    private _runWrite;
-    /**
-     * Открывает границу записи без closure; повторяет начало `_runWrite`.
-     *
-     * @internal
-     */
-    _enterWrite(): void;
-    /**
-     * Закрывает успешную запись, открытую `_enterWrite`; внешняя граница очищает
-     * transient causes и запускает фазы с теми же ошибками, что и `_runWrite`.
-     *
-     * @internal
-     */
-    _exitWrite(): void;
-    /**
-     * Закрывает запись после ошибки операции и возвращает ошибку для throw:
-     * исходную либо AggregateError, если упало и закрытие внешней границы.
-     *
-     * @internal
-     */
-    _failWrite(operationError: unknown): unknown;
-    /**
-     * Сообщает, что внешняя write-, batch-, Kernel- или disposal-граница ещё открыта.
-     * В этом состоянии оба шага `_finishExecutionBoundary` заведомо ничего не делают:
-     * transient causes очищаются и фазы запускаются только при нулевых глубинах.
-     */
-    private _executionBoundaryOpen;
-    /** Закрывает внешнюю границу; массив ошибок создаётся только при первой ошибке. */
-    private _finishExecutionBoundary;
-    private _clearTransientCausesIfSettled;
-    private _requestExecution;
-    private _assertTrackedRead;
-    /**
-     * Проверяет tracked read из optional owned source.
-     *
-     * @internal
-     */
-    _assertSourceReadable(owner: RaphScope): void;
-    private _assertImplicitDependency;
-    private _assertWriteAllowed;
-    private _throwCrossRuntime;
-    private _assertAlive;
+    protected _applyBatch<Args extends unknown[], Result>(operation: (...args: Args) => Result, args: ArrayLike<Args[number]>, receiver?: unknown): Result;
+    protected _runDataBatch<T>(operation: () => T): T;
+    protected _disposeDataSources(errors: unknown[]): void;
+    protected _detachDataPlane(errors: unknown[]): void;
 }

package/dist/runtime/RaphRuntimeBase.d.ts

@@ -0,0 +1,194 @@
+import { Disposer, ReadonlySignal, Signal, WritableComputedOptions } from '../reactivity/types.js';
+import { RaphDebugController, RaphMachineDebugRegistration, RaphTraceEventInput, RaphTraceKind } from './diagnostics/RaphDebug.js';
+import { DepGraph } from './ownership/parent-graph.types.js';
+import { NodeOptions, RaphNode } from './ownership/RaphNode.js';
+import { FrameLoopLease, RaphAggregateSource, RaphEffectGroupOptions, RaphEffectGroupSlot, RaphEffectInitialMode, RaphEffectOptions, RaphPhase, RaphPhaseEffect, RaphSchedulerMode, RaphStructureCause, RaphWatchOptions, RaphWatchSource } from './phases/phase.types.js';
+import { RaphPhaseState, RaphPhasePipeline } from './phases/RaphPhasePipeline.js';
+import { RaphAggregate, RaphWorkGraph } from './reactivity/RaphWorkGraph.js';
+import { RuntimeDisposalSweeper, RuntimeSignalLifecycle } from './reactivity/runtime-reactivity.types.js';
+import { RuntimeObjectSupport } from './reactivity/RuntimeObjectSupport.js';
+import { RuntimeSignal, RuntimeReactivity } from './reactivity/RuntimeReactivity.js';
+import { RuntimeSelectorSupport } from './reactivity/RuntimeSelectorSupport.js';
+import { RaphScope } from './ownership/RaphScope.js';
+import { RaphFrameLoop } from './phases/RaphFrameLoop.js';
+import { RaphPhaseTaskRecord } from './phases/RaphPhaseTaskRecord.js';
+export interface RaphPausableRegistration {
+    readonly active: boolean;
+    readonly dispose: (this: RaphPausableRegistration) => void;
+    readonly pause: (this: RaphPausableRegistration) => void;
+    readonly resume: (this: RaphPausableRegistration) => void;
+}
+export interface RaphExecutionRuntimeOptions {
+    readonly adaptiveDependencyIndex?: boolean;
+    readonly id?: string;
+    readonly enforceActions?: boolean;
+    readonly scheduler?: RaphSchedulerMode;
+}
+export interface RaphExecutionRuntimeConfiguration {
+    readonly adaptiveDependencyIndex: boolean;
+    readonly id: string;
+    readonly enforceActions: boolean;
+    readonly scheduler: RaphSchedulerMode;
+}
+export declare function resolveRuntimeConfiguration(options: RaphExecutionRuntimeOptions): RaphExecutionRuntimeConfiguration;
+export declare class RaphRuntimeBase<Runtime extends RaphRuntimeBase<Runtime>> {
+    readonly reactiveObjects: boolean;
+    readonly selectors: boolean;
+    protected readonly _reactiveObjects: RuntimeObjectSupport | undefined;
+    readonly mode: "runtime";
+    readonly configuration: RaphExecutionRuntimeConfiguration;
+    readonly rootScope: RaphScope<Runtime>;
+    readonly root: RaphNode<unknown, Runtime>;
+    readonly frameTick: ReadonlySignal<number>;
+    protected readonly _reactivity: RuntimeReactivity;
+    protected readonly _signalLifecycle: RuntimeSignalLifecycle;
+    protected readonly _workGraph: RaphWorkGraph;
+    protected readonly _frameTickSignal: RuntimeSignal<number>;
+    protected _phases: RaphPhasePipeline | undefined;
+    protected _frameLoop: RaphFrameLoop | undefined;
+    protected readonly _debugController: RaphDebugController | undefined;
+    protected _parentGraph: DepGraph | undefined;
+    protected readonly _topOwners: Set<RaphScope<any>>;
+    protected _ownerRegistrations: number;
+    protected _ownersReleased: boolean;
+    protected _batchDepth: number;
+    protected _mutationDepth: number;
+    protected _kernelBatchDepth: number;
+    protected _ownerDisposalDepth: number;
+    protected readonly _disposingNodes: Array<RaphNode<unknown, any> | undefined>;
+    protected _ownerDisposals: number;
+    protected _disposalSweepers: RuntimeDisposalSweeper[] | undefined;
+    protected _nextDisposalSweep: number;
+    protected _actionDepth: number;
+    protected _actionCounter: number;
+    protected readonly _traceCauseStack: number[];
+    protected _phaseTraceOperations: Map<string, number> | undefined;
+    protected _executionRequested: boolean;
+    protected _disposed: boolean;
+    protected readonly _disposedListeners: Set<() => void>;
+    private _checkedObjectPolicy;
+    private _fastObjectPolicy;
+    constructor(configuration: RaphExecutionRuntimeConfiguration, diagnostics?: RaphDebugController, objects?: RuntimeObjectSupport, selectors?: RuntimeSelectorSupport);
+    _getReactivity(): RuntimeReactivity;
+    _getWorkGraph(): RaphWorkGraph;
+    get id(): string;
+    get disposed(): boolean;
+    get graph(): DepGraph;
+    get loopEnabled(): boolean;
+    get frame(): import('./phases/phase.types.js').RaphFrameContext;
+    get phases(): readonly RaphPhase<Runtime>[];
+    signal<T>(value: T, owner?: RaphScope<any>): Signal<T>;
+    reactive<T extends object>(value: this['reactiveObjects'] extends false ? never : T): T;
+    computed<T>(getter: () => T, owner?: RaphScope<any>): ReadonlySignal<T>;
+    computed<T>(options: WritableComputedOptions<T>, owner?: RaphScope<any>): Signal<T>;
+    effect(consumer: RaphScope<any>, phaseInput: string, callback: RaphPhaseEffect<Runtime>, options?: RaphEffectOptions): Disposer;
+    _effectRegistration(consumer: RaphScope<any>, phaseInput: string, callback: RaphPhaseEffect<Runtime>, options?: RaphEffectOptions, startPaused?: boolean, taskless?: boolean, onExecutionFailure?: (error: unknown) => never, isExecutionCancelled?: () => boolean): RaphPausableRegistration;
+    _effectGroupRegistration(consumer: RaphScope<any>, phaseInput: string, count: number, runSlot: RaphEffectGroupSlot, context: unknown, options?: RaphEffectGroupOptions, startPaused?: boolean): RaphPhaseTaskRecord;
+    _startGroupSlot(record: RaphPhaseTaskRecord, slot: number, initial: RaphEffectInitialMode, onExecutionFailure?: (error: unknown) => never): void;
+    watch(consumer: RaphScope<any>, source: RaphWatchSource<Runtime>, phaseInput: string, callback: RaphPhaseEffect<Runtime>, options?: RaphWatchOptions): Disposer;
+    _watchRegistration(consumer: RaphScope<any>, source: RaphWatchSource<Runtime>, phaseInput: string, callback: RaphPhaseEffect<Runtime>, options?: RaphWatchOptions, startPaused?: boolean, onExecutionFailure?: (error: unknown) => never, isExecutionCancelled?: () => boolean): RaphPhaseTaskRecord;
+    aggregate(consumer: RaphScope<Runtime>, sources: readonly RaphAggregateSource<Runtime>[]): RaphAggregate<Runtime>;
+    batch<T>(operation: () => T): T;
+    _batchReactive<T>(operation: () => T): T;
+    protected _batch<T>(operation: () => T, includeKernel: boolean): T;
+    protected _closeBatch(operationFailed: boolean, operationError: unknown): void;
+    protected _applyBatch<Args extends unknown[], Result>(operation: (...args: Args) => Result, args: ArrayLike<Args[number]>, receiver?: unknown): Result;
+    action<Args extends unknown[], Result>(operation: (...args: Args) => Result, owner?: RaphScope<any>): (...args: Args) => Result;
+    action<Args extends unknown[], Result>(name: string, operation: (...args: Args) => Result, owner?: RaphScope<any>): (...args: Args) => Result;
+    /**
+     * Общее исполнение public action и class methods, без второго массива аргументов.
+     * @internal
+     */
+    _invokeAction<Args extends unknown[], Result>(name: string, owner: RaphScope<any>, operation: (...args: Args) => Result, args: ArrayLike<Args[number]>, receiver?: unknown): Result;
+    untracked<T>(operation: () => T): T;
+    /**
+     * Выполняет операцию вне owner context и сообщает, было ли в ней отслеживаемое
+     * чтение. Ни одной зависимости операция не оставляет. Renderer так проверяет,
+     * что значение зависит только от переданных данных и не требует effect.
+     * @internal
+     */
+    _probeReads(operation: () => void): boolean;
+    scope(id: string): RaphScope<Runtime>;
+    node<TApi = void>(options: NodeOptions<Runtime>, setup?: (node: RaphNode<unknown, Runtime>) => TApi): RaphNode<TApi, Runtime>;
+    protected _createCommittedNode<TApi>(options: NodeOptions<Runtime>, setup: ((node: RaphNode<unknown, Runtime>) => TApi) | undefined): RaphNode<TApi, Runtime>;
+    getNode(id: string): RaphNode<unknown, Runtime> | undefined;
+    definePhases(phases: readonly RaphPhase<Runtime>[]): void;
+    addPhase(phase: RaphPhase<Runtime>): void;
+    clearPhases(): void;
+    requestExecution(): void;
+    flush(): void;
+    afterFlush(): Promise<void>;
+    acquireLoop(owner: string): FrameLoopLease;
+    startLoop(): void;
+    stopLoop(): void;
+    dispose(): void;
+    _onDisposed(listener: () => void): Disposer;
+    _notifyNodeStructure(node: RaphNode<unknown, any>, structure: RaphStructureCause<Runtime>, oldAncestors: readonly RaphNode<unknown, any>[], newAncestors: readonly RaphNode<unknown, any>[]): void;
+    _hasNodeStructureDemand(node: RaphNode<unknown, any>): boolean;
+    _hasNodeSubscribers(): boolean;
+    _notifyNodeTouch(node: RaphNode<unknown, any>, metadata?: unknown): void;
+    _assertNodeReparentAllowed(node: RaphNode<unknown, any>, newParent: RaphNode<unknown, any>): void;
+    _releaseNode(node: RaphNode<unknown, any>): void;
+    _runNodeMutation<T>(operation: () => T): T;
+    _touchMutationBoundary(): void;
+    _runPhaseTransition<T>(operation: () => T): T;
+    _beginOwnerDisposal(node?: RaphNode<unknown, any>): void;
+    _endOwnerDisposal(): void;
+    _ownerDisposalCount(): number;
+    _addDisposalSweeper(sweeper: RuntimeDisposalSweeper, due: number): void;
+    _removeDisposalSweeper(sweeper: RuntimeDisposalSweeper): void;
+    protected _sweepAfterDisposals(): void;
+    _ownerDisposalActive(): boolean;
+    _registerOwner(owner: RaphScope<any>): number;
+    _unregisterOwner(owner: RaphScope<any>): void;
+    _addTopOwner(node: RaphNode<unknown, any>): void;
+    _removeTopOwner(node: RaphNode<unknown, any>): void;
+    _assertOwnerRuntime(owner: RaphScope<any>): void;
+    _beginKernelBatch(): void;
+    _endKernelBatch(): void;
+    _registerMachineDebug(registration: RaphMachineDebugRegistration): Disposer;
+    _hasMachineDebug(id: string): boolean;
+    _traces(kind: RaphTraceKind): boolean;
+    _currentTraceCauseId(): number | undefined;
+    _nextTraceOperation(kind: RaphTraceKind): number | undefined;
+    _hasActiveReactiveContext(): boolean;
+    _recordTrace(event: RaphTraceEventInput): void;
+    _runWithTraceCause<T>(causeId: number | undefined, operation: () => T): T;
+    protected _validatePhaseBinding(execution: RaphPhasePipeline, phaseInput: string, callback: RaphPhaseEffect<Runtime>, options: RaphEffectOptions | RaphWatchOptions, allowNoInitial?: boolean): RaphPhaseState;
+    protected _rollbackRegistration(record: RaphPhaseTaskRecord, error: unknown, message: string, onExecutionFailure?: (error: unknown) => never): never;
+    protected _liveOwnerCount(): number;
+    protected _collectOwners(): RaphScope<any>[];
+    protected get _execution(): RaphPhasePipeline;
+    private _phaseTraceListener?;
+    protected _syncPhaseTrace(): void;
+    private _tracePhase;
+    protected get _clock(): RaphFrameLoop;
+    protected _tickFrameLoop(): void;
+    protected _setFrameTick(value: number): void;
+    protected _attachWritableComputed<T>(source: ReadonlySignal<T>, setter: (value: T) => void, owner: RaphScope<any>): Signal<T>;
+    protected _own(disposer: Disposer, owner: RaphScope<any>): Disposer;
+    protected _runTracked<T>(owner: RaphScope<any>, operation: () => T): T;
+    protected _runUntracked<T>(operation: () => T): T;
+    protected _runWrite<T>(operation: () => T, invalidate?: boolean): T;
+    /** @internal */
+    _isWriteBatchOpen(): boolean;
+    _enterWrite(): void;
+    _exitWrite(): void;
+    _failWrite(operationError: unknown): unknown;
+    protected _requestPendingExecution(): void;
+    protected _executionBoundaryOpen(): boolean;
+    protected _finishExecutionBoundary(): unknown[] | undefined;
+    protected _clearTransientCausesIfSettled(): void;
+    protected _requestExecution(): void;
+    /** @internal */
+    _applyObjectReadPolicy(checked: boolean): void;
+    protected _assertTrackedRead(): void;
+    _assertSourceReadable(owner: RaphScope<any>): void;
+    protected _assertImplicitDependency(sourceOwner: RaphScope<any>, consumerOwner: RaphScope<any>): void;
+    protected _assertWriteAllowed(): void;
+    protected _throwCrossRuntime(owner: RaphRuntimeBase<Runtime>): never;
+    protected _assertAlive(): void;
+    protected _runDataBatch<T>(operation: () => T): T;
+    protected _disposeDataSources(_errors: unknown[]): void;
+    protected _detachDataPlane(_errors: unknown[]): void;
+}