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

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

@@ -1,5 +1,5 @@
-import { Disposer } from '../../reactivity/types';
-import { RaphScope } from '../ownership/RaphScope';
+import { Disposer } from '../../reactivity/types.js';
+import { RaphScope } from '../ownership/RaphScope.js';
 export type RaphTraceKind = 'action' | 'error' | 'machine' | 'phase';
 export type RaphTraceGuardMode = 'all' | 'failed' | 'none';
 export type RaphTraceContextMode = 'keys' | 'none';
@@ -146,6 +146,7 @@ export interface RaphRuntimeDebug {
  * @internal
  */
 export declare class RaphDebugController {
+    private readonly _onTraceChange?;
     private _capacity;
     private _context;
     private _guards;
@@ -157,12 +158,13 @@ export declare class RaphDebugController {
     private _sequence;
     private _operationSequence;
     private _machines;
+    private readonly _traceTarget?;
     readonly trace: RaphDebugTraceApi;
     readonly machines: RaphDebugMachinesApi;
     /**
      * Создаёт controller; ring buffer появляется только при включённом trace.
      */
-    constructor(options?: RaphDebugOptions);
+    constructor(options?: RaphDebugOptions, traceTarget?: object, _onTraceChange?: ((this: object) => void) | undefined);
     /**
      * Включает trace с текущими или явно переданными настройками.
      */
@@ -171,6 +173,7 @@ export declare class RaphDebugController {
      * Останавливает запись, сохраняя уже накопленные events.
      */
     stop(): void;
+    private _notifyTraceChange;
     /**
      * Удаляет все накопленные events, не меняя status trace.
      */
@@ -235,5 +238,5 @@ export declare class RaphDebugController {
     private _applyOptions;
     private _ensureBuffer;
 }
-export declare function createOwnerSnapshot(owner: RaphScope): RaphDebugOwnerSnapshot;
-export declare function createOwnerTree(owner: RaphScope, machinesByOwner?: ReadonlyMap<string, readonly RaphDebugTreeNode[]>): RaphDebugTreeNode;
+export declare function createOwnerSnapshot(owner: RaphScope<any>): RaphDebugOwnerSnapshot;
+export declare function createOwnerTree(owner: RaphScope<any>, machinesByOwner?: ReadonlyMap<string, readonly RaphDebugTreeNode[]>): RaphDebugTreeNode;

package/dist/runtime/errors.d.ts

@@ -1,4 +1,4 @@
-import { RaphError } from '../api/errors';
+import { RaphError } from '../api/errors.js';
 /**
  * Сообщает о записи вне action при включённом enforceActions.
  */

package/dist/runtime/ownership/RaphEffectScope.d.ts

@@ -1,9 +1,10 @@
-import { Disposer } from '../../reactivity/types';
-import { RaphEffectGroup, RaphEffectGroupOptions, RaphEffectGroupSlot, RaphEffectOptions, RaphOwnerWatchSource, RaphPhaseBody, RaphPhaseEffect, RaphWatchOptions, RaphWatchSource } from '../phases/phase.types';
-import { RaphRuntime } from '../RaphRuntime';
-import { RaphScope } from './RaphScope';
+import { Disposer } from '../../reactivity/types.js';
+import { RaphEffectGroup, RaphEffectGroupOptions, RaphEffectGroupSlot, RaphEffectOptions, RaphOwnerWatchSource, RaphPhaseBody, RaphPhaseEffect, RaphWatchOptions, RaphWatchSource } from '../phases/phase.types.js';
+import { RaphRuntime } from '../RaphRuntime.js';
+import { RaphRuntimeBase } from '../RaphRuntimeBase.js';
+import { RaphScope } from './RaphScope.js';
 /** Pauses phase deliveries without detaching dependencies or losing accumulated causes. */
-export declare class RaphEffectScope {
+export declare class RaphEffectScope<Runtime extends RaphRuntimeBase<Runtime> = RaphRuntime> {
     private readonly _owner;
     private _registrations;
     private _pruneAt;
@@ -13,11 +14,11 @@ export declare class RaphEffectScope {
     private _disposed;
     private readonly _releaseOwner;
     private readonly _parent;
-    constructor(_owner: RaphScope, parent?: RaphEffectScope | null);
+    constructor(_owner: RaphScope<Runtime>, parent?: RaphEffectScope<Runtime> | null);
     get paused(): boolean;
     get disposed(): boolean;
-    fork(owner: RaphScope): RaphEffectScope;
-    effect(phase: string, callback: RaphPhaseEffect, options?: RaphEffectOptions): Disposer;
+    fork(owner: RaphScope<Runtime>): RaphEffectScope<Runtime>;
+    effect(phase: string, callback: RaphPhaseEffect<Runtime>, options?: RaphEffectOptions): Disposer;
     /**
      * Регистрирует в этой группе phase effect без task и без disposer: тело
      * вызывается без аргументов, а binding живёт до освобождения группы или её
@@ -57,17 +58,17 @@ export declare class RaphEffectScope {
      * @param options `priority` task группы, как у `effect()`.
      */
     effectGroup<Context>(phase: string, count: number, runSlot: RaphEffectGroupSlot<Context>, context: Context, options?: RaphEffectGroupOptions): RaphEffectGroup;
-    watch(source: RaphOwnerWatchSource, phase: string, callback: RaphPhaseEffect, options?: RaphWatchOptions): Disposer;
+    watch(source: RaphOwnerWatchSource<Runtime>, phase: string, callback: RaphPhaseEffect<Runtime>, options?: RaphWatchOptions): Disposer;
     /**
      * Внутренний путь renderer сохраняет pause ancestry и late-disposal tracking.
      * Возвращаемый disposer renderer не использует; регистрация остаётся у scope.
      * @internal
      */
-    _registerEffect(phase: string, callback: RaphPhaseEffect, options: RaphEffectOptions, taskless: boolean, onExecutionFailure: (error: unknown) => never, isExecutionCancelled?: () => boolean): void;
+    _registerEffect(phase: string, callback: RaphPhaseEffect<Runtime>, options: RaphEffectOptions, taskless: boolean, onExecutionFailure: (error: unknown) => never, isExecutionCancelled?: () => boolean): void;
     /** @internal */
-    _registerWatch(source: RaphWatchSource, phase: string, callback: RaphPhaseEffect, options: RaphWatchOptions, onExecutionFailure: (error: unknown) => never, isExecutionCancelled?: () => boolean): void;
+    _registerWatch(source: RaphWatchSource<Runtime>, phase: string, callback: RaphPhaseEffect<Runtime>, options: RaphWatchOptions, onExecutionFailure: (error: unknown) => never, isExecutionCancelled?: () => boolean): void;
     /** @internal */
-    _registerEffectGroup<Context>(phase: string, count: number, runSlot: RaphEffectGroupSlot<Context>, context: Context, options?: RaphEffectGroupOptions): ReturnType<RaphRuntime['_effectGroupRegistration']>;
+    _registerEffectGroup<Context>(phase: string, count: number, runSlot: RaphEffectGroupSlot<Context>, context: Context, options?: RaphEffectGroupOptions): ReturnType<RaphRuntimeBase<Runtime>['_effectGroupRegistration']>;
     pause(): void;
     resume(): void;
     private _pause;

package/dist/runtime/ownership/RaphNode.d.ts

@@ -1,10 +1,11 @@
-import { DisposalFailure } from '../../reactivity/disposal';
-import { RaphRuntime } from '../RaphRuntime';
-import { RaphScope } from './RaphScope';
-export interface NodeOptions {
+import { DisposalFailure } from '../../reactivity/disposal.js';
+import { RaphRuntime } from '../RaphRuntime.js';
+import { RaphRuntimeBase } from '../RaphRuntimeBase.js';
+import { RaphScope } from './RaphScope.js';
+export interface NodeOptions<Runtime extends RaphRuntimeBase<Runtime> = RaphRuntime> {
     readonly id?: string;
     readonly priority?: number;
-    readonly parent?: RaphNode;
+    readonly parent?: RaphNode<unknown, Runtime>;
     readonly meta?: Readonly<Record<string, unknown>>;
     readonly type?: string;
 }
@@ -13,11 +14,11 @@ export interface NodeOptions {
  * полем `node`. Позволяет передать на удаление уже существующий массив записей
  * без копии в массив nodes.
  */
-export interface RaphNodeHolder {
-    readonly node: RaphNode;
+export interface RaphNodeHolder<Runtime extends RaphRuntimeBase<Runtime> = RaphRuntime> {
+    readonly node: RaphNode<unknown, Runtime>;
 }
 /** Scope with an explicit parent/children ownership position. */
-export declare class RaphNode<TApi = unknown> extends RaphScope {
+export declare class RaphNode<TApi = unknown, Runtime extends RaphRuntimeBase<Runtime> = RaphRuntime> extends RaphScope<Runtime> {
     #private;
     priority: number;
     private _parent;
@@ -37,7 +38,7 @@ export declare class RaphNode<TApi = unknown> extends RaphScope {
     private _meta;
     type: string;
     private _subtreeIdentity;
-    constructor(parent: RaphNode | RaphRuntime | null, options?: Omit<NodeOptions, 'parent'>, runtime?: RaphRuntime, publication?: never);
+    constructor(parent: RaphNode<unknown, Runtime> | Runtime | null, options?: Omit<NodeOptions<Runtime>, 'parent'>, runtime?: Runtime, publication?: never);
     /**
      * Возвращает id; номер id по умолчанию превращается в `node-N` при первом чтении.
      */
@@ -56,8 +57,14 @@ export declare class RaphNode<TApi = unknown> extends RaphScope {
      * @internal
      */
     get _subtreeSourceIdentity(): object;
-    get node(): RaphNode<TApi>;
-    get parent(): RaphNode | null;
+    get node(): RaphNode<TApi, Runtime>;
+    get parent(): RaphNode<unknown, Runtime> | null;
+    /**
+     * Сообщает, является ли `owner` строгим предком узла: тот же обход, что по
+     * `parent`, но по полям, без вызова getter на каждом шаге.
+     * @internal
+     */
+    _hasAncestor(owner: RaphScope<any>): boolean;
     /**
      * Возвращает прямых детей в их порядке. Массив действителен до следующей
      * структурной mutation этой node; после неё порядок даёт новое чтение.
@@ -82,8 +89,8 @@ export declare class RaphNode<TApi = unknown> extends RaphScope {
      * дети выходят из него на месте и при отсутствии подписчика на node, а после
      * последнего child он тоже пуст.
      */
-    get children(): readonly RaphNode[];
-    addChild(node: RaphNode): boolean;
+    get children(): readonly RaphNode<unknown, Runtime>[];
+    addChild(node: RaphNode<unknown, Runtime>): boolean;
     /**
      * Ставит прямых детей в порядок `nodes`: в нём каждый прямой child ровно
      * один раз. Без подписчика на node порядок проверяется и применяется по
@@ -93,7 +100,7 @@ export declare class RaphNode<TApi = unknown> extends RaphScope {
      * меняет дерево — элемент Proxy либо accessor, — не оставляет списки в
      * промежуточном состоянии: порядок проверяется по составу детей после чтения.
      */
-    reorderChildren(nodes: readonly RaphNode[]): void;
+    reorderChildren(nodes: readonly RaphNode<unknown, Runtime>[]): void;
     /**
      * Ставит прямого child перед прямым child `before` либо в конец списка, если
      * `before === null`. Без подписчика на node меняются только связи самого
@@ -101,7 +108,7 @@ export declare class RaphNode<TApi = unknown> extends RaphScope {
      * child, чей индекс изменился, получает тот же structure cause, что и после
      * `reorderChildren` с итоговым порядком.
      */
-    moveChild(child: RaphNode, before: RaphNode | null): void;
+    moveChild(child: RaphNode<unknown, Runtime>, before: RaphNode<unknown, Runtime> | null): void;
     /**
      * Меняет местами двух прямых детей. Без подписчика на node правятся только
      * связи этих детей и их соседей; с подписчиком оба child получают те же
@@ -109,7 +116,7 @@ export declare class RaphNode<TApi = unknown> extends RaphScope {
      *
      * @internal
      */
-    _swapChildren(first: RaphNode, second: RaphNode): void;
+    _swapChildren(first: RaphNode<unknown, Runtime>, second: RaphNode<unknown, Runtime>): void;
     /**
      * Удаляет детей одной границей удаления и возвращает их ошибки вместо throw.
      *
@@ -146,8 +153,8 @@ export declare class RaphNode<TApi = unknown> extends RaphScope {
      */
     _disposeChildren(): unknown[] | undefined;
     /** @internal */
-    _disposeChildren(holders: readonly RaphNodeHolder[], start?: number, end?: number): unknown[] | undefined;
-    options(options: Pick<NodeOptions, 'meta' | 'priority' | 'type'>): void;
+    _disposeChildren(holders: readonly RaphNodeHolder<Runtime>[], start?: number, end?: number): unknown[] | undefined;
+    options(options: Pick<NodeOptions<Runtime>, 'meta' | 'priority' | 'type'>): void;
     /** Invalidates coarse self/subtree/runtime granules for non-reactive state. */
     touch(metadata?: unknown): void;
     remove(): void;
@@ -183,7 +190,7 @@ export declare class RaphNode<TApi = unknown> extends RaphScope {
      *
      * @internal
      */
-    _collectDescendants(into: RaphScope[]): void;
+    _collectDescendants(into: RaphScope<any>[]): void;
     /**
      * Прибавляет к `totals` число ресурсов и sources самой node и всех её
      * потомков. Обход тот же, что у `_collectDescendants`, но владельцев он не
@@ -201,7 +208,7 @@ export declare class RaphNode<TApi = unknown> extends RaphScope {
      *
      * @internal
      */
-    _findNode(id: string): RaphNode | undefined;
+    _findNode(id: string): RaphNode<unknown, Runtime> | undefined;
     /**
      * Применяет порядок детей `nodes`. Возвращает `false` и оставляет список
      * прежним, если `nodes` не содержит каждого живого прямого child ровно один
@@ -307,4 +314,4 @@ export declare class RaphNode<TApi = unknown> extends RaphScope {
     private _resetChildList;
 }
 /** Creates an unpublished node that Runtime.node() commits after setup. @internal */
-export declare function createProvisionalNode<TApi>(parent: RaphNode, options: Omit<NodeOptions, 'parent'>, runtime: RaphRuntime): RaphNode<TApi>;
+export declare function createProvisionalNode<TApi, Runtime extends RaphRuntimeBase<Runtime>>(parent: RaphNode<unknown, Runtime>, options: Omit<NodeOptions<Runtime>, 'parent'>, runtime: Runtime): RaphNode<TApi, Runtime>;

package/dist/runtime/ownership/RaphScope.d.ts

@@ -1,24 +1,25 @@
-import { DisposalFailure } from '../../reactivity/disposal';
-import { OwnedSourceEntry, ScopeOwner } from '../../reactivity/scope';
-import { Disposer, OwnedResource, OwnedSource, ReadonlySignal, Signal, WritableComputedOptions } from '../../reactivity/types';
-import { RaphAggregateSource, RaphEffectGroup, RaphEffectGroupOptions, RaphEffectGroupSlot, RaphEffectOptions, RaphPhaseBody, RaphPhaseEffect, RaphWatchOptions, RaphWatchSource } from '../phases/phase.types';
-import { RaphRuntime } from '../RaphRuntime';
-import { RaphSelector, RaphSelectorOptions } from '../reactivity/RaphSelector';
-import { RaphAggregate } from '../reactivity/RaphWorkGraph';
-import { RaphNode } from './RaphNode';
+import { DisposalFailure } from '../../reactivity/disposal.js';
+import { OwnedSourceEntry, ScopeOwner } from '../../reactivity/scope.js';
+import { Disposer, OwnedResource, OwnedSource, ReadonlySignal, Signal, WritableComputedOptions } from '../../reactivity/types.js';
+import { RaphAggregateSource, RaphEffectGroup, RaphEffectGroupOptions, RaphEffectGroupSlot, RaphEffectOptions, RaphPhaseBody, RaphPhaseEffect, RaphWatchOptions, RaphWatchSource } from '../phases/phase.types.js';
+import { RaphRuntime } from '../RaphRuntime.js';
+import { RaphRuntimeBase } from '../RaphRuntimeBase.js';
+import { RaphSelector, RaphSelectorOptions } from '../reactivity/RaphSelector.js';
+import { RaphAggregate } from '../reactivity/RaphWorkGraph.js';
+import { RaphNode } from './RaphNode.js';
 /**
  * Runtime owner. Список ресурсов, список источников и признаки lifetime
  * наследуются от ScopeOwner и лежат в самом владельце; standalone unphased
  * effect/watch класса ScopeNode Runtime-владелец намеренно не наследует.
  */
-export declare class RaphScope extends ScopeOwner {
+export declare class RaphScope<Runtime extends RaphRuntimeBase<Runtime> = RaphRuntime> extends ScopeOwner {
     /**
      * Явный id либо числовой номер id по умолчанию, который RaphNode
      * форматирует при первом чтении `id`.
      * @internal
      */
     protected _id: string | number;
-    readonly runtime: RaphRuntime;
+    readonly runtime: Runtime;
     /**
      * Порядковый номер регистрации владельца в его Runtime. Владельцы, пережившие
      * дерево root, Runtime при собственном освобождении обходит по этому номеру
@@ -32,18 +33,30 @@ export declare class RaphScope extends ScopeOwner {
      * @internal
      */
     readonly _isNode: boolean;
-    constructor(id: string, runtime: RaphRuntime);
+    /**
+     * Тот же признак, что `disposed`, открытый для горячих проверок: pipeline
+     * читает поле владельца записи binding, а чтение signal и регистрация —
+     * оба признака lifetime, без вызова getter или _assertAlive().
+     * @internal
+     */
+    _disposed: boolean;
+    /**
+     * Признак идущего освобождения, открытый для тех же проверок.
+     * @internal
+     */
+    _disposing: boolean;
+    constructor(id: string, runtime: Runtime);
     /**
      * Числовой id зарезервирован за ленивым id по умолчанию у RaphNode.
      * @internal
      */
-    constructor(id: string | number, runtime: RaphRuntime);
+    constructor(id: string | number, runtime: Runtime);
     /**
      * Возвращает id владельца; plain scope всегда хранит явную строку.
      */
     get id(): string;
     /** Stable selector for process ordering; plain scopes are not tree nodes. */
-    get node(): RaphNode | undefined;
+    get node(): RaphNode<unknown, Runtime> | undefined;
     signal<T>(value: T): Signal<T>;
     computed<T>(getter: () => T): ReadonlySignal<T>;
     computed<T>(options: WritableComputedOptions<T>): Signal<T>;
@@ -59,8 +72,8 @@ export declare class RaphScope extends ScopeOwner {
      *
      * @typeParam Key — тип ключа и значения `source`.
      */
-    selector<Key>(source: Signal<Key>, options?: RaphSelectorOptions<Key>): RaphSelector<Key>;
-    effect(phase: string, callback: RaphPhaseEffect, options?: RaphEffectOptions): Disposer;
+    selector<Key>(source: Runtime['selectors'] extends false ? never : Signal<Key>, options?: RaphSelectorOptions<Key>): RaphSelector<Key>;
+    effect(phase: string, callback: RaphPhaseEffect<Runtime>, options?: RaphEffectOptions): Disposer;
     /**
      * Регистрирует phase effect без task и без disposer. Тело вызывается без
      * аргументов, а binding живёт до освобождения этого владельца: отдельно его
@@ -117,22 +130,22 @@ export declare class RaphScope extends ScopeOwner {
      * @param options `priority` task группы, как у `effect()`.
      */
     effectGroup<Context>(phase: string, count: number, runSlot: RaphEffectGroupSlot<Context>, context: Context, options?: RaphEffectGroupOptions): RaphEffectGroup;
-    watch(source: RaphWatchSource, phase: string, callback: RaphPhaseEffect, options?: RaphWatchOptions): Disposer;
+    watch(source: RaphWatchSource<Runtime>, phase: string, callback: RaphPhaseEffect<Runtime>, options?: RaphWatchOptions): Disposer;
     /**
      * Внутренняя регистрация renderer без возвращаемого disposer. Failure
      * continuation относится только к завершившемуся execution request.
      * @internal
      */
-    _registerEffect(phase: string, callback: RaphPhaseEffect, options: RaphEffectOptions, taskless: boolean, onExecutionFailure: (error: unknown) => never, isExecutionCancelled?: () => boolean): void;
+    _registerEffect(phase: string, callback: RaphPhaseEffect<Runtime>, options: RaphEffectOptions, taskless: boolean, onExecutionFailure: (error: unknown) => never, isExecutionCancelled?: () => boolean): void;
     /** @internal */
-    _registerWatch(source: RaphWatchSource, phase: string, callback: RaphPhaseEffect, options: RaphWatchOptions, onExecutionFailure: (error: unknown) => never, isExecutionCancelled?: () => boolean): void;
+    _registerWatch(source: RaphWatchSource<Runtime>, phase: string, callback: RaphPhaseEffect<Runtime>, options: RaphWatchOptions, onExecutionFailure: (error: unknown) => never, isExecutionCancelled?: () => boolean): void;
     /**
      * Выдаёт внутренний typed handle вместо приведения публичного group handle.
      * Порядок создания и принятия ресурса совпадает с effectGroup().
      * @internal
      */
     _registerEffectGroup<Context>(phase: string, count: number, runSlot: RaphEffectGroupSlot<Context>, context: Context, options?: RaphEffectGroupOptions): ReturnType<RaphRuntime['_effectGroupRegistration']>;
-    aggregate(sources: readonly RaphAggregateSource[]): RaphAggregate;
+    aggregate(sources: readonly RaphAggregateSource<Runtime>[]): RaphAggregate<Runtime>;
     action<Args extends unknown[], Result>(operation: (...args: Args) => Result): (...args: Args) => Result;
     action<Args extends unknown[], Result>(name: string, operation: (...args: Args) => Result): (...args: Args) => Result;
     own(disposer: Disposer): Disposer;

package/dist/runtime/ownership/parent-graph.types.d.ts

@@ -1,4 +1,4 @@
-import { RaphNode } from './RaphNode';
+import { RaphNode } from './RaphNode.js';
 export interface DepGraph<T extends RaphNode = RaphNode> {
     parentsOf: (node: T) => ReadonlySet<T>;
 }

package/dist/runtime/ownership/parentGraph.d.ts

@@ -1,3 +1,3 @@
-import { DepGraph } from './parent-graph.types';
-import { RaphNode } from './RaphNode';
+import { DepGraph } from './parent-graph.types.js';
+import { RaphNode } from './RaphNode.js';
 export declare function parentGraph<T extends RaphNode>(): DepGraph<T>;

package/dist/runtime/phases/RaphFrameLoop.d.ts

@@ -1,4 +1,4 @@
-import { FrameLoopLease } from './phase.types';
+import { FrameLoopLease } from './phase.types.js';
 /**
  * Ленивые frame callbacks не запускаются обычной реактивной работой.
  */

package/dist/runtime/phases/RaphPhasePipeline.d.ts

@@ -1,20 +1,22 @@
-import { RaphScope } from '../ownership/RaphScope';
-import { RuntimeReactivity } from '../reactivity/RuntimeReactivity';
-import { RaphFrameContext, RaphPhase, RaphPhaseEffect, RaphSchedulerMode, RaphWorkCause } from './phase.types';
-import { RaphPhaseTaskRecord } from './RaphPhaseTaskRecord';
+import { RaphScope } from '../ownership/RaphScope.js';
+import { RuntimeReactivity } from '../reactivity/RuntimeReactivity.js';
+import { RaphFrameContext, RaphPhase, RaphPhaseEffect, RaphSchedulerMode, RaphWorkCause } from './phase.types.js';
+import { RaphPhaseTaskRecord } from './RaphPhaseTaskRecord.js';
 /**
- * Постоянное состояние одной phase: живая очередь, запасной массив для обмена
- * при разборе и число bindings. Состояние переживает переопределение phases, пока
+ * Постоянное состояние одной phase: первый binding, хвост живой очереди,
+ * запасной массив для обмена при разборе и число bindings.
+ * Состояние переживает переопределение phases, пока
  * имя phase сохраняется, поэтому запись binding держит прямую ссылку на него и
  * ставится в очередь без поиска по имени. Через него же запись находит свой
  * pipeline: отдельной ссылки на pipeline у записи нет.
  *
- * Инвариант: каждая запись живой очереди активна и ожидает доставки, а
+ * Инвариант: first и каждая запись хвоста активны и ожидают доставки, а
  * `spare` пуст вне разбора своей phase.
  */
 export declare class RaphPhaseState {
     readonly name: string;
     readonly pipeline: RaphPhasePipeline;
+    first: RaphPhaseTaskRecord | undefined;
     queue: RaphPhaseTaskRecord[];
     spare: RaphPhaseTaskRecord[];
     bindings: number;
@@ -26,11 +28,18 @@ export declare class RaphPhasePipeline {
     private readonly _reactivity;
     private readonly _resolveCause;
     private readonly _deferSync;
-    private readonly _tracePhase?;
+    private _tracePhase?;
     private _phases;
     private _phaseByName;
-    private _resolvedInput;
-    private _resolvedState;
+    /**
+     * Последнее разрешённое имя phase в том виде, в каком его передал вызывающий,
+     * и его состояние. Регистрация binding читает этот кэш сама, без вызова
+     * resolvePhase().
+     * @internal
+     */
+    _resolvedInput: string | undefined;
+    /** @internal */
+    _resolvedState: RaphPhaseState | undefined;
     private _queuedCount;
     private readonly _deferred;
     private readonly _idleWaiters;
@@ -52,11 +61,31 @@ export declare class RaphPhasePipeline {
     private _lastFrameAt;
     private _frameNumber;
     private _frame;
-    constructor(_scheduler: RaphSchedulerMode, _reactivity: RuntimeReactivity, _resolveCause: (token: unknown) => RaphWorkCause | undefined, _deferSync?: () => boolean, _tracePhase?: ((phase: string, status: "end" | "error" | "start", error?: unknown) => void) | undefined);
+    private _publicFrames;
+    private _frameStale;
+    private _unmeasuredFrame;
+    private _firstReadFrame;
+    private _readPublicFrame;
+    private readonly _now;
+    constructor(_scheduler: RaphSchedulerMode, _reactivity: RuntimeReactivity, _resolveCause: (token: unknown) => RaphWorkCause<any> | undefined, _deferSync?: () => boolean, _tracePhase?: ((phase: string, status: "end" | "error" | "start", error?: unknown) => void) | undefined);
+    /** @internal */
+    _setPhaseTrace(trace: RaphPhasePipeline['_tracePhase']): void;
     get frame(): RaphFrameContext;
-    get phases(): readonly RaphPhase[];
-    definePhases(phases: readonly RaphPhase[]): void;
-    addPhase(phase: RaphPhase): void;
+    private _readCurrentFrame;
+    private _exposeCurrentFrame;
+    /**
+     * Доставка может удерживать ещё не опубликованный снимок.
+     * @internal
+     */
+    _frameForDelivery(): RaphFrameContext;
+    /**
+     * Первое чтение включает заморозку всех последующих кадров.
+     * @internal
+     */
+    _exposeFrame(frame: RaphFrameContext): RaphFrameContext;
+    get phases(): readonly RaphPhase<any>[];
+    definePhases(phases: readonly RaphPhase<any>[]): void;
+    addPhase(phase: RaphPhase<any>): void;
     clearPhases(): void;
     /**
      * Находит состояние объявленной phase по имени, которое передал вызывающий.
@@ -70,7 +99,7 @@ export declare class RaphPhasePipeline {
      * Запись ничего не выполняет, пока вызывающий не подключит engine effect
      * (`node`) или watch lifecycle (`watch`).
      */
-    bindTask(phase: RaphPhaseState, consumerOwner: RaphScope, effect: RaphPhaseEffect, priority: number): RaphPhaseTaskRecord;
+    bindTask(phase: RaphPhaseState, consumerOwner: RaphScope<any>, effect: RaphPhaseEffect<any>, priority: number): RaphPhaseTaskRecord;
     /**
      * Создаёт постоянную запись группы из `count` slots: одна запись binding и
      * её состояние с местом под запись графа каждого slot. Вызывающий уже
@@ -83,25 +112,31 @@ export declare class RaphPhasePipeline {
      * группы, где лежат её context и номер slot. Поэтому запись группы несёт
      * `TASK_TASKLESS`: вместо task тело получает поле `group`.
      */
-    bindGroup(phase: RaphPhaseState, consumerOwner: RaphScope, runSlot: RaphPhaseEffect, context: unknown, count: number, priority: number): RaphPhaseTaskRecord;
+    bindGroup(phase: RaphPhaseState, consumerOwner: RaphScope<any>, runSlot: RaphPhaseEffect<any>, context: unknown, count: number, priority: number): RaphPhaseTaskRecord;
     request(): void;
     afterFlush(): Promise<void>;
     flush(): void;
-    dispose(): void;
-    _debugPending(): boolean;
-    private _describeQueued;
     /**
-     * Открывает доставку одной записью `state`. Накопленные причины остаются на
-     * своих местах и становятся причинами доставки под TASK_CAUSES_DELIVERED:
-     * ничего не копируется, а массив для `task.causes` строится, только если его
-     * прочитают. Frame доставки получает только запись с facade: без facade его
-     * нечем прочитать, а запись ссылки на новый frame в каждую доставленную
-     * запись стоит write barrier.
+     * Raph Top-1: первая доставка нового binding в простаивающем sync pipeline.
+     * Запись встаёт в очередь так же, как через `_queue()`, и разбирается тем же
+     * проходом flush, но без цепочки engine schedule → `_schedule()` → пролог
+     * flush. False значит, что pipeline не простаивает: тогда вызывающий
+     * планирует запись обычным путём.
      *
-     * Запись попадает сюда только из живой очереди, а в ней нет записей с
-     * открытой доставкой, поэтому причин прошлой доставки здесь не бывает.
+     * @internal
      */
-    private _beginDelivery;
+    _canDeliverFirst(record: RaphPhaseTaskRecord): boolean;
+    /**
+     * Выполняет первую доставку после положительного `_canDeliverFirst()`.
+     *
+     * @internal
+     */
+    _deliverFirst(record: RaphPhaseTaskRecord): void;
+    /** Основной проход flush: `_running` уже выставлен, frame выбран. */
+    private _drain;
+    dispose(): void;
+    _debugPending(): boolean;
+    private _describeQueued;
     /**
      * Исполняет открытую доставку binding. `failures` передаёт default runner:
      * группа складывает туда сбой каждого slot отдельно. Без него сбои slots
@@ -135,7 +170,7 @@ export declare class RaphPhasePipeline {
     /** @internal */
     _notifyTask(record: RaphPhaseTaskRecord, token: unknown): void;
     /** @internal */
-    _appendCause(record: RaphPhaseTaskRecord, cause: RaphWorkCause, key: object): void;
+    _appendCause(record: RaphPhaseTaskRecord, cause: RaphWorkCause<any>, key: object): void;
     /**
      * Переносит причины открытой доставки с места ожидающих в detail, без
      * копирования, и освобождает это место. После вызова запись хранит оба
@@ -155,6 +190,8 @@ export declare class RaphPhasePipeline {
      * @internal
      */
     _disposeBinding(record: RaphPhaseTaskRecord): void;
+    /** Callback создаётся только на пути explicit watch после очистки record.watch. */
+    private _stopPhaseWatch;
     /**
      * Убирает из состояния группы slots, записи графа которых уже остановлены, и
      * сообщает, остались ли при этом живые slots.
@@ -215,9 +252,23 @@ export declare class RaphPhasePipeline {
     private _scheduleDeferredTurn;
     private _cancelScheduled;
     private _activateDeferred;
+    /** Flush без читателей frame: только номер кадра, без clock и снимка. */
+    private _skipFrame;
+    /**
+     * Вычисляет текущий кадр при первом чтении. История до него не записывалась,
+     * поэтому кадр считается первым измеренным: delta и elapsed равны нулю.
+     */
+    private _materializeFrame;
     private _nextFrame;
     private _assertRetainedPhases;
     private _hasPending;
+    /**
+     * Есть ли то, что изменит flush(): очередь, отложенные записи, запланированный
+     * turn или ожидающие afterFlush(). Без этого flush() ничего не делает.
+     *
+     * @internal
+     */
+    _hasPendingWork(): boolean;
     private _cancelAllQueued;
     private _cancelAllDeferred;
     private _acknowledgeDiscard;