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

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 {
+}

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

@@ -0,0 +1,98 @@
+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';
+/** Pauses phase deliveries without detaching dependencies or losing accumulated causes. */
+export declare class RaphEffectScope {
+    private readonly _owner;
+    private _registrations;
+    private _pruneAt;
+    private _children;
+    private _selfPaused;
+    private _ancestorPauses;
+    private _disposed;
+    private readonly _releaseOwner;
+    private readonly _parent;
+    constructor(_owner: RaphScope, parent?: RaphEffectScope | null);
+    get paused(): boolean;
+    get disposed(): boolean;
+    fork(owner: RaphScope): RaphEffectScope;
+    effect(phase: string, callback: RaphPhaseEffect, options?: RaphEffectOptions): Disposer;
+    /**
+     * Регистрирует в этой группе phase effect без task и без disposer: тело
+     * вызывается без аргументов, а binding живёт до освобождения группы или её
+     * владельца. Pause и resume группы действуют на него так же, как на effect,
+     * зарегистрированный через `effect()`.
+     *
+     * Binding, зарегистрированный внутри тела другого effect, останавливает ещё и
+     * перезапуск этого effect. Остановленный binding больше не исполняется и не
+     * реагирует на pause и resume; группа забывает его не сразу, а когда число её
+     * регистраций удваивается, поэтому остановленных регистраций в группе не
+     * больше, чем действующих, либо меньше `PRUNE_FLOOR`.
+     */
+    bindEffect(phase: string, body: RaphPhaseBody, options?: RaphEffectOptions): void;
+    /**
+     * Регистрирует в этой группе регистраций группу из `count` phase effects на
+     * одном binding, как `owner.effectGroup()`: без task и без disposer, с
+     * отдельным набором зависимостей у каждого slot и с запуском slots через
+     * `start()` возвращённой группы. Pause и resume действуют на все slots
+     * сразу; slots, запущенные или изменившиеся за время pause, исполняются
+     * одной доставкой после resume. Binding живёт до освобождения этой группы
+     * регистраций или её владельца.
+     *
+     * Pause изнутри тела slot останавливает доставку: оставшиеся slots
+     * исполняются после resume, и причины прерванной доставки приходят в
+     * `causes` следующей целиком, вместе с причинами уже исполненных slots.
+     *
+     * Освобождение отличается от отдельных bindings этой же группы регистраций:
+     * slots останавливаются в порядке, обратном порядку номеров, а не в порядке
+     * регистрации, и несколько сбоев их cleanup приходят одним вложенным
+     * `AggregateError` с сообщением `[Raph] Effect group disposal failed.`.
+     *
+     * @typeParam Context — значение, которое получает тело каждого slot.
+     * @param phase Имя объявленной phase.
+     * @param count Число slots: целое от 1 до 4294967293, иначе `RangeError`.
+     * @param runSlot Тело slot: получает запуск с `context` и номером slot.
+     * @param context Значение, которое группа передаёт телу каждого slot.
+     * @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;
+    /**
+     * Внутренний путь 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;
+    /** @internal */
+    _registerWatch(source: RaphWatchSource, phase: string, callback: RaphPhaseEffect, 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']>;
+    pause(): void;
+    resume(): void;
+    private _pause;
+    private _resume;
+    dispose(): void;
+    private _add;
+    /**
+     * Вносит регистрацию в группу и возвращает её элемент либо `undefined`,
+     * когда группа уже освобождена. Disposer здесь не создаётся: его строит
+     * только `_add()`, поэтому `bindEffect()` обходится без closure.
+     */
+    private _track;
+    /**
+     * Забывает регистрации, которые уже остановлены не через disposer группы:
+     * binding, вложенный в тело другого effect, останавливает engine при
+     * перезапуске этого effect, а у `bindEffect()` нет disposer, который убрал бы
+     * его отсюда. Без этого группа держала бы тело каждого такого binding до
+     * собственного освобождения.
+     *
+     * Проход выполняется, когда число регистраций достигает порога, и ставит
+     * следующий порог вдвое выше числа оставшихся: цена регистрации остаётся
+     * постоянной в среднем.
+     */
+    private _prune;
+    private _assertAlive;
+    private _addChild;
+    private _changeAncestorPause;
+}

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

@@ -0,0 +1,310 @@
+import { DisposalFailure } from '../../reactivity/disposal';
+import { RaphRuntime } from '../RaphRuntime';
+import { RaphScope } from './RaphScope';
+export interface NodeOptions {
+    readonly id?: string;
+    readonly priority?: number;
+    readonly parent?: RaphNode;
+    readonly meta?: Readonly<Record<string, unknown>>;
+    readonly type?: string;
+}
+/**
+ * Запись, которая знает свою node: сама RaphNode либо объект потребителя с
+ * полем `node`. Позволяет передать на удаление уже существующий массив записей
+ * без копии в массив nodes.
+ */
+export interface RaphNodeHolder {
+    readonly node: RaphNode;
+}
+/** Scope with an explicit parent/children ownership position. */
+export declare class RaphNode<TApi = unknown> extends RaphScope {
+    #private;
+    priority: number;
+    private _parent;
+    private _prevSibling;
+    private _nextSibling;
+    private _firstChild;
+    private _lastChild;
+    /**
+     * Число прямых детей. Structural owner читает его, чтобы узнать состав
+     * списка, не строя массив `children`; изменяет поле только сама node.
+     *
+     * @internal
+     */
+    _childCount: number;
+    private _childArray;
+    private _published;
+    private _meta;
+    type: string;
+    private _subtreeIdentity;
+    constructor(parent: RaphNode | RaphRuntime | null, options?: Omit<NodeOptions, 'parent'>, runtime?: RaphRuntime, publication?: never);
+    /**
+     * Возвращает id; номер id по умолчанию превращается в `node-N` при первом чтении.
+     */
+    get id(): string;
+    /**
+     * Возвращает изменяемую metadata node; объект создаётся при первом чтении.
+     */
+    get meta(): Record<string, unknown>;
+    set meta(value: Record<string, unknown>);
+    /**
+     * Возвращает api, зафиксированный после setup; присваивание снаружи запрещено.
+     */
+    get api(): Readonly<TApi>;
+    /**
+     * Отличает subtree granule от self granule; identity создаётся по запросу.
+     * @internal
+     */
+    get _subtreeSourceIdentity(): object;
+    get node(): RaphNode<TApi>;
+    get parent(): RaphNode | null;
+    /**
+     * Возвращает прямых детей в их порядке. Массив действителен до следующей
+     * структурной mutation этой node; после неё порядок даёт новое чтение.
+     *
+     * Добавление в конец, удаление последнего child и `reorderChildren`
+     * обновляют уже выданный массив на месте. После удаления любого другого
+     * child — первого или из середины — выданный массив либо остаётся прежним, и
+     * следующее чтение строит новый, либо обновляется на месте — второе
+     * происходит, пока у Runtime есть подписчик на node.
+     *
+     * `moveChild` и `_swapChildren` следуют тому же правилу, что и удаление не
+     * последнего child: без подписчика на node выданный массив остаётся прежним,
+     * с подписчиком получает новый порядок на месте. `_disposeChildren` забывает
+     * выданный массив, если набор начинается с первого child списка: массив
+     * хранит состав на начало удаления. Набор, который начинается с другого
+     * child, следует правилу отдельных удалений.
+     *
+     * Собственный dispose node выданный массив не обновляет: пока node удаляет
+     * своих детей, он хранит их состав на начало удаления, а после удаления
+     * последнего child становится пустым. Оставшихся детей в это время даёт
+     * новое чтение; выданный им массив остаётся массивом node до конца удаления:
+     * дети выходят из него на месте и при отсутствии подписчика на node, а после
+     * последнего child он тоже пуст.
+     */
+    get children(): readonly RaphNode[];
+    addChild(node: RaphNode): boolean;
+    /**
+     * Ставит прямых детей в порядок `nodes`: в нём каждый прямой child ровно
+     * один раз. Без подписчика на node порядок проверяется и применяется по
+     * связям между siblings, без Set и Map.
+     *
+     * Каждый элемент `nodes` читается один раз, до проверки. Чтение, которое само
+     * меняет дерево — элемент Proxy либо accessor, — не оставляет списки в
+     * промежуточном состоянии: порядок проверяется по составу детей после чтения.
+     */
+    reorderChildren(nodes: readonly RaphNode[]): void;
+    /**
+     * Ставит прямого child перед прямым child `before` либо в конец списка, если
+     * `before === null`. Без подписчика на node меняются только связи самого
+     * child и его соседей: цена не зависит от числа детей. С подписчиком каждый
+     * child, чей индекс изменился, получает тот же structure cause, что и после
+     * `reorderChildren` с итоговым порядком.
+     */
+    moveChild(child: RaphNode, before: RaphNode | null): void;
+    /**
+     * Меняет местами двух прямых детей. Без подписчика на node правятся только
+     * связи этих детей и их соседей; с подписчиком оба child получают те же
+     * structure causes, что и после `reorderChildren` с итоговым порядком.
+     *
+     * @internal
+     */
+    _swapChildren(first: RaphNode, second: RaphNode): void;
+    /**
+     * Удаляет детей одной границей удаления и возвращает их ошибки вместо throw.
+     *
+     * Без аргументов удаляются все дети node, какими они были на момент вызова.
+     * С `holders` удаляются nodes записей `holders[start]`…`holders[end - 1]`:
+     * ожидается, что это прямые дети node. Массив записей служит snapshot набора
+     * и не копируется: child, которого cleanup более раннего child уже удалил,
+     * пропускается, перенесённый к другому parent всё равно удаляется, а дети,
+     * добавленные во время удаления, в набор не входят.
+     *
+     * Каждый child удаляется собственным `dispose()` в порядке набора: порядок
+     * cleanup, structure causes при наличии подписчика и ошибка каждого child те
+     * же, что у отдельных вызовов `dispose()` внутри одного batch. Ошибка child
+     * не прерывает удаление остальных; ошибки возвращаются в порядке набора,
+     * последней — ошибка phases, исполненных при закрытии границы.
+     *
+     * Граница одна на весь набор: phases, запрошенные cleanup, исполняются после
+     * последнего child, а не между детьми. Это граница удаления владельца, как у
+     * `RaphNode.dispose()`, а не reactive batch: запись signal из cleanup
+     * применяется сразу, и её phase tasks встают в очередь в момент записи, в
+     * порядке отдельных удалений. Внутри `batch` та же запись откладывается до
+     * его конца, поэтому порядок phase tasks у batch другой.
+     *
+     * Выданный массив `children` node забывает до первого child, если набор
+     * начинается с первого child списка либо набором передан сам этот массив: он
+     * остаётся у того, кто его держит, с составом на начало удаления, и удаление
+     * набора от первого child списка не правит его через `shift`, `splice` или
+     * `indexOf` даже при подписчике на node. Набор, который начинается с другого
+     * child, следует правилу отдельных `dispose()`: последний child уходит из
+     * массива через pop, остальные вырезаются на месте при подписчике на node, а
+     * без подписчика массив забывается первым же удалением.
+     *
+     * @internal
+     */
+    _disposeChildren(): unknown[] | undefined;
+    /** @internal */
+    _disposeChildren(holders: readonly RaphNodeHolder[], start?: number, end?: number): unknown[] | undefined;
+    options(options: Pick<NodeOptions, 'meta' | 'priority' | 'type'>): void;
+    /** Invalidates coarse self/subtree/runtime granules for non-reactive state. */
+    touch(metadata?: unknown): void;
+    remove(): void;
+    dispose(): void;
+    /** Calls actual public dispatch once; only native disposal can return provenance. @internal */
+    _disposeForOwner(): DisposalFailure | undefined;
+    /** Result of this exact framework call, without changing raw public disposal. @internal */
+    _disposeWithOutcome(): DisposalFailure | undefined;
+    /**
+     * Фиксирует api после setup; object api замораживается, как и раньше.
+     * Исключение — Runtime signal, возвращённый как api: значение, запись графа
+     * и связи подписчиков лежат в его собственных полях, поэтому заморозка
+     * лишила бы его записи, отслеживаемого чтения, watch и освобождения вместе
+     * с владельцем.
+     * @internal
+     */
+    _setApi(api: TApi): void;
+    /** Publishes a fully initialized provisional subtree. @internal */
+    _publishCreation(): void;
+    /** @internal */
+    _isPublished(): boolean;
+    /**
+     * Сообщает, стоит ли node в списке детей своего parent. Node без parent и
+     * node, чей parent уже сбросил свой список, в нём не стоят.
+     *
+     * @internal
+     */
+    _isLinked(): boolean;
+    /**
+     * Добавляет в `into` всех потомков node по связям списков детей: каждый
+     * child сразу за своим parent, дети — в порядке списка. Обход не строит
+     * массивы `children` и не зависит от глубины стека.
+     *
+     * @internal
+     */
+    _collectDescendants(into: RaphScope[]): void;
+    /**
+     * Прибавляет к `totals` число ресурсов и sources самой node и всех её
+     * потомков. Обход тот же, что у `_collectDescendants`, но владельцев он не
+     * собирает: подсчёт для diagnostics не выделяет память по числу владельцев.
+     *
+     * @internal
+     */
+    _countSubtree(totals: {
+        resources: number;
+        sources: number;
+    }): void;
+    /**
+     * Ищет node по id в своём поддереве. Порядок обхода прежний: сама node,
+     * затем дети от последнего к первому, каждый вместе со своим поддеревом.
+     *
+     * @internal
+     */
+    _findNode(id: string): RaphNode | undefined;
+    /**
+     * Применяет порядок детей `nodes`. Возвращает `false` и оставляет список
+     * прежним, если `nodes` не содержит каждого живого прямого child ровно один
+     * раз. Прежние индексы собираются только при подписчике на node: без него
+     * structure cause никто не получит.
+     */
+    private _applyChildOrder;
+    /**
+     * Проверяет порядок и переставляет связи за три прохода без Set и Map.
+     * Сначала каждый child списка получает метку: его `_prevSibling` указывает на
+     * parent, чего у прямого child не бывает. Затем метка снимается у каждой node
+     * из `nodes`: node без метки — чужая, удаляемая либо повторная. При отказе
+     * и при ошибке чтения `nodes` связи `_prevSibling` восстанавливаются по
+     * нетронутым `_nextSibling`.
+     *
+     * `nodes` — собственная копия порядка: её чтение не исполняет чужой код, и
+     * между расстановкой меток и их снятием дерево никто не меняет.
+     */
+    private _relinkChildren;
+    /**
+     * Сообщает причину отказа порядка `nodes` теми же ошибками и в том же
+     * порядке, что и прежняя проверка; Set нужен только здесь.
+     */
+    private _rejectChildOrder;
+    /**
+     * Запоминает индекс каждого child до перестановки; нужен только для
+     * structure causes.
+     */
+    private _indexChildren;
+    /**
+     * Завершает перестановку связей при подписчике на node: массив детей
+     * получает новый порядок на месте либо строится, и каждый child со
+     * сменившимся индексом получает structure cause.
+     */
+    private _publishChildOrder;
+    /**
+     * Публикует structure cause каждому child, чей индекс изменился, в новом
+     * порядке детей и одной границей mutation.
+     */
+    private _notifyChildOrder;
+    /**
+     * Переставляет child перед `before` либо в конец списка, меняя только связи
+     * child и его соседей. Вызывающий гарантирует, что оба — дети этой node и
+     * что child ещё не стоит перед `before`.
+     */
+    private _relinkBefore;
+    /**
+     * Строит массив детей по связям и запоминает его для следующих чтений.
+     */
+    private _materializeChildren;
+    /**
+     * Собирает детей по связям в новый массив, не запоминая его.
+     */
+    private _collectChildren;
+    /**
+     * Очищает и забывает выданный массив детей, если он есть.
+     */
+    private _clearChildArray;
+    /**
+     * Добавляет child в конец списка; уже выданный массив получает его через push.
+     */
+    private _appendChild;
+    /**
+     * Возвращает позицию node среди детей `parent` либо -1, если `parent` уже
+     * сбросил свой список и node в нём не состоит. Нужна только для structure
+     * cause. Первый и последний child определяются по связям, остальные — через
+     * `indexOf` по массиву детей, как и раньше; массив строится один раз и затем
+     * поддерживается, поэтому обход связей на каждый запрос не повторяется.
+     */
+    private _indexIn;
+    /**
+     * Вынимает node из списка `parent` и обнуляет её связи, чтобы удержанная node
+     * не удерживала соседей. Связи правятся за постоянное время.
+     *
+     * Уже выданный массив теряет последний child через pop. Любой другой child —
+     * первый или из середины — вырезается на месте, только если его `index`
+     * известен (>= 0) либо у Runtime есть подписчик на node: тогда массив ещё
+     * понадобится для индексов и перестраивать его по связям после каждого
+     * удаления дороже. Иначе массив не правится, а отбрасывается, и следующее
+     * чтение `children` строит новый: очистка списка от первого child к
+     * последнему не сдвигает массив на каждое удаление.
+     *
+     * Пока parent удаляет собственных детей, массив не отбрасывается: его мог
+     * запросить только cleanup уже удаляемого child, и `_resetChildList` обязан
+     * очистить именно его. Отброшенный массив остался бы у cleanup с удалёнными
+     * детьми внутри.
+     */
+    private _unlinkFrom;
+    /**
+     * Возвращает snapshot детей для их удаления. Уже выданный массив
+     * переиспользуется без копии и на время удаления перестаёт быть массивом
+     * node: дети выходят из списка только через связи, snapshot не сдвигается, и
+     * удаление не платит за `shift` на каждого child. Иначе snapshot строится по
+     * связям.
+     */
+    private _takeChildSnapshot;
+    /**
+     * Сбрасывает собственный список после удаления детей. `snapshot` мог быть
+     * выданным массивом: как и раньше, у удалённой node он остаётся пустым.
+     * Массив, запрошенный во время удаления, очищается так же: `_unlinkFrom` не
+     * отбрасывает его, пока node удаляет своих детей.
+     */
+    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>;