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

package/dist/runtime/RaphRuntime.d.ts

@@ -1,285 +1,444 @@
-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, 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';
 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;
 }
+export type RaphRuntimeMeta = Pick<RaphMeta, 'delete' | 'get' | 'has' | 'merge' | 'set'>;
 /**
- * Один изолированный signal execution-plane поверх собственного или shared Kernel.
+ * Один 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";
     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;
     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 readonly _topOwners;
+    private _ownerRegistrations;
+    private _ownersReleased;
+    private _batchDepth;
     private _mutationDepth;
-    private _kernelTransactionDepth;
+    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;
-    /**
-     * Создаёт изолированный 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.
+    /** 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
      */
-    effect(callback: () => void | Disposer, owner?: RaphScope): Disposer;
-    effect(phase: string, callback: () => void | Disposer, options?: RaphEffectOptions, owner?: RaphScope): Disposer;
-    /**
-     * Подписывает runtime owner на path- либо signal-изменения.
+    _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
      */
-    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.
+    _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
      */
-    path<T>(path: DataPathDef, options?: PathOptions): PathHandle<T>;
+    _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;
     /**
-     * Возвращает весь path-root Kernel с обычным tracking чтения.
+     * Регистрирует один 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;
-    /**
-     * Возвращает значение 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;
+    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>;
     /**
-     * Выполняет операцию в общей синхронной transaction boundary.
+     * Создаёт provisional node, выполняет setup и публикует результат; при ошибке
+     * setup откатывает node до выхода из границы mutation.
      */
-    transaction<T>(operation: () => T): T;
+    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;
     /**
-     * Создаёт именованную action boundary для разрешённых записей.
+     * Сообщает, может ли structural publication этой node дойти до подписчика;
+     * `false` позволяет не строить structure cause и списки ancestors.
+     *
+     * @internal
      */
-    action<Args extends unknown[], Result>(name: string, operation: (...args: Args) => Result, owner?: RaphScope): (...args: Args) => Result;
+    _hasNodeStructureDemand(node: RaphNode): boolean;
     /**
-     * Выполняет операцию внутри action boundary.
+     * Сообщает, есть ли у Runtime хотя бы один подписчик на node: runtime-,
+     * subtree- или self-watcher. Пока он есть, node поддерживает выданный массив
+     * детей на месте, потому что structure cause берёт из него индексы.
+     *
+     * @internal
      */
-    runInAction<T>(_name: string, operation: () => T): T;
-    /**
-     * Выполняет операцию без регистрации реактивных зависимостей.
+    _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
      */
-    untracked<T>(operation: () => T): T;
+    _touchMutationBoundary(): void;
+    /** @internal */
+    _runPhaseTransition<T>(operation: () => T): T;
     /**
-     * Создаёт дочерний lifecycle scope.
+     * Открывает границу освобождения. `node` передаёт только dispose самой node:
+     * Runtime помнит её до парного `_endOwnerDisposal`.
+     *
+     * @internal
      */
-    scope(id: string): RaphScope;
+    _beginOwnerDisposal(node?: RaphNode): void;
+    /** @internal */
+    _endOwnerDisposal(): void;
     /**
-     * Создаёт дочерний execution node.
+     * Возвращает число владельцев, освобождённых этим Runtime за всё время.
+     *
+     * @internal
      */
-    node<TApi>(options: NodeOptions, setup: (node: RaphNode) => TApi): RaphNode<TApi>;
+    _ownerDisposalCount(): number;
     /**
-     * Находит принадлежащий runtime node по id для диагностики.
+     * Подключает участника уборки: Runtime вызовет его на первой внешней границе
+     * освобождения, к которой число освобождённых владельцев достигнет `due`.
+     * Подключённый участник остаётся в очереди, пока сам не откажется от
+     * следующего срока либо не будет отключён.
+     *
+     * @internal
      */
-    getNode(id: string): RaphNode | undefined;
+    _addDisposalSweeper(sweeper: RuntimeDisposalSweeper, due: number): void;
     /**
-     * Заменяет полное определение phase pipeline до его первого выполнения.
+     * Отключает участника уборки; отключение неизвестного участника безопасно.
+     *
+     * @internal
      */
-    definePhases(phases: readonly RaphPhase[]): void;
+    _removeDisposalSweeper(sweeper: RuntimeDisposalSweeper): void;
     /**
-     * Добавляет phase до первого выполнения pipeline.
+     * Вызывает участников уборки, чей срок подошёл, и назначает ближайший
+     * следующий срок. Участник, чей срок не подошёл, вызова не получает:
+     * освобождение владельца стоит участникам работы, только когда подходит их
+     * собственный срок.
      */
-    addPhase(phase: RaphPhase): void;
+    private _sweepAfterDisposals;
+    /** @internal */
+    _ownerDisposalActive(): boolean;
     /**
-     * Удаляет пользовательские phases до первого выполнения pipeline.
+     * Учитывает нового владельца и возвращает его порядковый номер регистрации.
+     * Plain scope сразу входит в набор владельцев вне списков детей; node входит
+     * в него сама через `_addTopOwner`, и только если у неё нет parent.
+     *
+     * @internal
      */
-    clearPhases(): void;
+    _registerOwner(owner: RaphScope): number;
     /**
-     * Регистрирует path observer в phase pipeline.
+     * Снимает владельца с учёта. Plain scope выходит и из набора владельцев вне
+     * списков детей; node без parent выходит из него сама через
+     * `_removeTopOwner`, а node с parent в нём не состоит.
+     *
+     * @internal
      */
-    observeData(node: RaphNode, masks: DataPathDef | readonly DataPathDef[], options: RaphObserveDataOptions): Disposer;
+    _unregisterOwner(owner: RaphScope): void;
     /**
-     * Регистрирует tracked executor указанной phase.
+     * Вносит node без parent в набор владельцев вне списков детей.
+     *
+     * @internal
      */
-    track(node: RaphNode, masks: DataPathDef | readonly DataPathDef[], options?: RaphTrackOptions): Disposer;
+    _addTopOwner(node: RaphNode): void;
     /**
-     * Помечает node для выполнения в pipeline.
+     * Убирает node из набора владельцев вне списков детей: она освобождена либо
+     * получила parent. Повторный вызов и вызов после освобождения Runtime
+     * безопасны.
+     *
+     * @internal
      */
-    invalidateNode(node: RaphNode, phase: string): void;
-    /**
-     * Синхронно выполняет все готовые очереди pipeline.
+    _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
      */
-    flush(): void;
+    _hasMachineDebug(id: string): boolean;
     /**
-     * Получает lease автоматического frame-loop.
+     * Проверяет optional trace path без выделения operation ID.
+     *
+     * @internal
      */
-    acquireLoop(owner: string): FrameLoopLease;
+    _traces(kind: RaphTraceKind): boolean;
+    /** Возвращает наследуемый cause для optional execution layers. @internal */
+    _currentTraceCauseId(): number | undefined;
+    /** Выдаёт operation id только на активном trace path. @internal */
+    _nextTraceOperation(kind: RaphTraceKind): number | undefined;
     /**
-     * Запускает manual lease автоматического frame-loop.
+     * Проверяет, должен ли untracked work изолировать reactive или Runtime owner context.
+     *
+     * @internal
      */
-    startLoop(): void;
+    _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;
     /**
-     * Останавливает manual lease автоматического frame-loop.
+     * Выполняет единственную проверку binding: pipeline доверяет её результату.
      */
-    stopLoop(): void;
+    private _validatePhaseBinding;
     /**
-     * Создаёт управляемое derived-представление source path в target path.
+     * Освобождает binding, регистрация которого не удалась, и повторно бросает
+     * причину сбоя; ошибка самого освобождения присоединяется к ней.
      */
-    derive<TSource, TTarget>(options: DerivedOptions<TSource, TTarget>): RaphDerivedHandle<TSource, TTarget>;
+    private _rollbackRegistration;
+    private _createDebugSnapshot;
+    private _createDebugTree;
+    private _createDebugStats;
     /**
-     * Освобождает execution graph и отсоединяет runtime от shared Kernel.
+     * Возвращает число владельцев, которых Runtime числит живыми: зарегистрированных
+     * и ещё не снятых с учёта. После освобождения Runtime их нет.
      */
-    dispose(): void;
+    private _liveOwnerCount;
     /**
-     * Регистрирует listener освобождения runtime.
-     * @internal
+     * Собирает всех владельцев, которых Runtime числит живыми. Владельцы вне
+     * списков детей идут в порядке регистрации, каждый — вместе с потомками по
+     * спискам детей. Node, чей dispose ещё исполняется, из списка parent уже
+     * вышла либо потеряла parent, который сбросил свой список: её и оставшихся
+     * у неё детей добавляют места границ освобождения.
      */
-    _onDisposed(listener: () => void): Disposer;
-    private _watchPath;
-    private _createDebugSnapshot;
-    private _watchMeta;
-    private _watchMetaInPhase;
+    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;
     /**
-     * Регистрирует lifecycle owner в runtime registry.
+     * Открывает границу записи без closure; повторяет начало `_runWrite`.
+     *
      * @internal
      */
-    _registerOwner(owner: RaphScope): void;
+    _enterWrite(): void;
     /**
-     * Удаляет lifecycle owner из runtime registry.
+     * Закрывает успешную запись, открытую `_enterWrite`; внешняя граница очищает
+     * transient causes и запускает фазы с теми же ошибками, что и `_runWrite`.
+     *
      * @internal
      */
-    _unregisterOwner(owner: RaphScope): void;
+    _exitWrite(): void;
     /**
-     * Проверяет, что owner принадлежит этому живому runtime.
+     * Закрывает запись после ошибки операции и возвращает ошибку для throw:
+     * исходную либо AggregateError, если упало и закрытие внешней границы.
+     *
      * @internal
      */
-    _assertOwnerRuntime(owner: RaphScope): void;
-    private _runTracked;
-    private _runUntracked;
-    private _runWrite;
-    private _requestExecution;
+    _failWrite(operationError: unknown): unknown;
     /**
-     * Открывает shared Kernel transaction для runtime.
-     * @internal
+     * Сообщает, что внешняя write-, batch-, Kernel- или disposal-граница ещё открыта.
+     * В этом состоянии оба шага `_finishExecutionBoundary` заведомо ничего не делают:
+     * transient causes очищаются и фазы запускаются только при нулевых глубинах.
      */
-    _beginKernelTransaction(): void;
+    private _executionBoundaryOpen;
+    /** Закрывает внешнюю границу; массив ошибок создаётся только при первой ошибке. */
+    private _finishExecutionBoundary;
+    private _clearTransientCausesIfSettled;
+    private _requestExecution;
+    private _assertTrackedRead;
     /**
-     * Закрывает 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;
 }