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

package/dist/path/RaphKernel.d.ts

@@ -3,6 +3,7 @@ import { RaphMetaEvents, RaphMetaReadOptions, RaphMetaWatchOptions, RaphMetaWrit
 import { RaphMeta } from './meta/RaphMeta';
 import { DataPathDef, PathOptions, PathWatchCallback } from './path.types';
 import { DataAdapter, DataObject, DefaultAdapterOptions } from './storage/data-adapter.types';
+import { PathEventHub } from './storage/PathEventHub';
 export type RaphKernelRoot = DataObject;
 export interface RaphKernelOptions {
     readonly id?: string;
@@ -25,6 +26,8 @@ export declare class RaphKernel {
     private _derivedController;
     private _runtimes;
     private _metaController;
+    private _soleRuntime;
+    private _pathBatch;
     private _batchDepth;
     private _runtimeMutationDepth;
     private _stabilizing;
@@ -86,6 +89,27 @@ export declare class RaphKernel {
      * Выполняет операцию в общей синхронной batch boundary.
      */
     batch<T>(operation: () => T): T;
+    /**
+     * Открывает то же, что `batch()`, для единственного присоединённого Runtime
+     * без closure операции и без массивов: границу этого Runtime и path batch.
+     * Возвращает владельца path batch, которого вызывающий передаёт в
+     * `_closeSoleRuntimeBatch()` после операции.
+     *
+     * Возвращает `undefined` и ничего не открывает в любом другом состоянии:
+     * Kernel разделяют несколько Runtime, граница Runtime уже открыта, есть
+     * derived handles либо metadata watchers, store построен над adapter. Тогда
+     * вызывающий исполняет `batch()`. Состояние читается при входе, как в
+     * `batch()`: то, что появилось во время операции, выход не меняет.
+     * @internal
+     */
+    _openSoleRuntimeBatch(runtime: RaphKernelRuntime): PathEventHub | undefined;
+    /**
+     * Закрывает границу, открытую `_openSoleRuntimeBatch()`, в порядке `batch()`:
+     * публикация path events, затем граница Runtime. Бросает то же, что бросил бы
+     * `batch()` с этой операцией; после успешного выхода возвращает управление.
+     * @internal
+     */
+    _closeSoleRuntimeBatch(runtime: RaphKernelRuntime, hub: PathEventHub, operationFailed: boolean, operationError: unknown): void;
     /**
      * Подписывает callback на подходящие изменения и возвращает disposer.
      */

package/dist/path/storage/PathEventHub.d.ts

@@ -40,6 +40,20 @@ export declare class PathEventHub {
      * Выполняет операцию в общей синхронной batch boundary.
      */
     batch<T>(operation: () => T): T;
+    /**
+     * Открывает batch boundary без closure операции: вызывающий сам исполняет
+     * операцию и закрывает boundary через `_closeBatch()`.
+     * @internal
+     */
+    _openBatch(): void;
+    /**
+     * Закрывает один уровень batch boundary: на внешнем уровне публикует
+     * накопленные события. Бросает то же, что `batch()`: ошибку операции, ошибку
+     * публикации либо обе в AggregateError; после успешной операции и публикации
+     * возвращает управление.
+     * @internal
+     */
+    _closeBatch(operationFailed: boolean, operationError: unknown): void;
     /**
      * Подписывает callback на подходящие изменения и возвращает disposer.
      */

package/dist/path/storage/PathStore.d.ts

@@ -1,4 +1,5 @@
 import { DataPathDef, PathApi, PathOptions, PathWatchCallback } from '../path.types';
+import { PathEventHub } from './PathEventHub';
 /**
  * Владеет одним независимым path-root, mutation log и watch-router.
  */
@@ -6,12 +7,11 @@ export declare class PathStore implements PathApi {
     private _root;
     private readonly _eventHub;
     /**
-     * Возвращает внутренний router для диагностического контракта Kernel.
+     * Возвращает владельца batch boundary этого store: Kernel открывает и
+     * закрывает её без closure операции.
      * @internal
      */
-    private get _router();
-    private get _events();
-    private get _watcherCount();
+    get _batchHub(): PathEventHub;
     /**
      * Возвращает значение по пути без создания отсутствующих данных.
      */

package/dist/reactivity/disposal.d.ts

@@ -0,0 +1,14 @@
+/** Failure of one completed disposal call; never thrown as a wrapper. @internal */
+export interface DisposalFailure {
+    readonly error: unknown;
+    readonly hasUnrouted: boolean;
+    readonly completed?: {
+        readonly error: unknown;
+    };
+}
+/** An authored callback or a non-resource disposal stage failed. @internal */
+export declare function unroutedDisposalFailure(error: unknown): DisposalFailure;
+/** Combines only errors collected by this framework operation, without inspecting payloads. @internal */
+export declare function combineDisposalFailures(failures: readonly DisposalFailure[] | undefined, message: string): DisposalFailure | undefined;
+/** Public disposal exposes only the original raw payload. @internal */
+export declare function throwDisposalFailure(failure: DisposalFailure | undefined): void;

package/dist/reactivity/engine.d.ts

@@ -1,4 +1,4 @@
-import { ComputedAccessHandle, Disposer, EffectCallback, EffectFactory, OwnedSource, OwnedSourceHooks, ReactivityOptions, ReadonlySignal, Signal, SignalAccess, WatchCallback, WatchOptions, WatchSource, WritableComputedOptions } from './types';
+import { ComputedAccessHandle, Disposer, EffectCallback, EffectFactory, EffectTask, OwnedSource, OwnedSourceHooks, ReactiveNode, ReactivityOptions, ReadonlySignal, Signal, SignalAccess, WatchCallback, WatchOptions, WatchSource, WritableComputedOptions } from './types';
 import { ScopeNode } from './scope';
 export { ScopeNode } from './scope';
 export type { Disposer, EffectCallback, EffectScheduler, EffectTask, ReactivityOptions, ReadonlySignal, Signal, WatchCallback, WatchOptions, WatchSource, WatchValue, WritableComputedOptions, } from './types';
@@ -16,6 +16,7 @@ export declare class RaphReactivity {
     private effectWriteIndex;
     private invalidationDepth;
     private dependencyDepth;
+    private checkingDepth;
     private flushingEffects;
     private readonly effectQueue;
     private readonly invalidationStack;
@@ -127,8 +128,9 @@ export declare class RaphReactivity {
     private writeSignalValue;
     /**
      * Возвращает кеш либо синхронно актуализирует вычисляемое значение.
-     * Неуспешное вычисление не считается значением. Даже ошибочное чтение сохраняет
-     * связь с активным потребителем, чтобы тот мог восстановиться при изменении источника.
+     * Неуспешное вычисление не считается значением. Ошибка getter сохраняет связь
+     * с активным потребителем для восстановления. Повторное чтение во время
+     * первого сбора зависимостей отклоняется до регистрации связи и чтения кеша.
      */
     private readComputedValue;
     /**
@@ -183,7 +185,7 @@ export declare class RaphReactivity {
     /**
      * Удаляет непрочитанный хвост зависимостей завершившегося запуска.
      * trackedTail обозначает границу прочитанного префикса, а не неизменный конец списка.
-     * Удаление из списков производителей не выполняет пользовательские callbacks.
+     * Ошибка cleanup не прерывает освобождение оставшегося хвоста зависимостей.
      */
     private pruneUnreadDependencies;
     /**
@@ -192,6 +194,8 @@ export declare class RaphReactivity {
      * Также исправляет курсор поиска, если он указывал на удаляемую связь.
      */
     private detachSubLink;
+    /** Завершает удаление producer-связи без вызова source cleanup. */
+    private unlinkSubLink;
     /** Connects Runtime ownership metadata only for edges whose producer opted in. */
     private attachDependencyCleanup;
     /**
@@ -217,6 +221,7 @@ export declare class RaphReactivity {
      * не выполняет. Непосредственное и потенциальное изменения отмечает разными флагами.
      */
     private propagateInvalidation;
+    private markActiveChecks;
     /**
      * Помечает работающего потребителя, только если затронута уже прочитанная связь.
      * Связи за trackedTail принадлежат прошлому запуску и не означают повторную invalidation.
@@ -237,6 +242,8 @@ export declare class RaphReactivity {
      * Неверное значение в кеш не записывается.
      */
     private recomputeValue;
+    /** Сохраняет первичную ошибку и отдельные ошибки cleanup при восстановлении. */
+    private failComputedValue;
     /**
      * Восстанавливает связи и состояния после неудачного getter.
      * Отдельная функция удерживает обработку исключений вне обычной части пересчёта.
@@ -290,6 +297,7 @@ export declare class RaphReactivity {
      * Ошибка одного элемента не оставляет необработанные записи со старым SCHEDULED.
      */
     private flushExternalEffects;
+    private markRecoveryDependencies;
     /**
      * Завершает очередь после первой ошибки, собирая последующие причины сбоя.
      * Вызывается только на ошибочном пути; успешный проход не создаёт массив ошибок
@@ -381,6 +389,171 @@ export declare class RaphReactivity {
      * @internal
      */
     _isFlushingEffects(): boolean;
+    /**
+     * Создаёт запись графа для эффекта с внешним планированием и подключает его
+     * постоянную задачу. Запуск ещё не запрошен: вызывающий слой сохраняет запись
+     * и затем вызывает _requestTaskEffect(). Запись, созданная во время работы
+     * другого эффекта, становится его вложенным ресурсом.
+     * @internal
+     */
+    _allocateTaskEffect(fn: EffectCallback, task: EffectTask): ReactiveNode;
+    /**
+     * Запрашивает первый запуск эффекта с задачей. При `schedule` задача получает
+     * schedule(), как на пути scheduler bind; без него вызывающий слой уже сам
+     * поставил задачу в очередь, и запись только помечается запланированной.
+     * Если метод бросает исключение, запись освобождает вызывающий слой.
+     * @internal
+     */
+    _requestTaskEffect(node: ReactiveNode, schedule: boolean): void;
+    /**
+     * Открывает одну доставку эффекта с задачей. Возвращает false для устаревшей
+     * доставки: запись остановлена или запуск больше не запланирован.
+     * @internal
+     */
+    _beginTaskEffectRun(node: ReactiveNode): boolean;
+    /**
+     * Выполняет доставку, открытую через _beginTaskEffectRun(), вне активного
+     * потребителя и затем обрабатывает очередь эффектов, в том числе после
+     * неудачного запуска; при двух сбоях передаёт обе причины.
+     * @internal
+     */
+    _finishTaskEffectRun(node: ReactiveNode): void;
+    /**
+     * Гасит ожидающую доставку, от которой отказывается задача. Вызывающий слой
+     * не должен отменять доставку до первого запуска: зависимости до него ещё не
+     * собраны. Возвращает false, если запись уже остановлена.
+     * @internal
+     */
+    _cancelTaskEffect(node: ReactiveNode): boolean;
+    /**
+     * Делает следующую доставку исполняемой и снова планирует задачу. Нужен,
+     * когда invalidation пришла после снимка текущей доставки: её запуск
+     * расходует предыдущее dirty-состояние.
+     * @internal
+     */
+    _rearmTaskEffect(node: ReactiveNode): void;
+    /**
+     * Окончательно останавливает эффект с задачей. Engine один раз вызывает
+     * task.dispose() изнутри, поэтому задача может направлять собственное
+     * освобождение через этот метод.
+     * @internal
+     */
+    _disposeTaskEffect(node: ReactiveNode): void;
+    /**
+     * Материализует signal для активного потребителя и связывает их. Без
+     * потребителя возвращает undefined: signal остаётся значением у вызывающего
+     * слоя. После материализации значением владеет запись.
+     * @internal
+     */
+    _trackSignalNode<T>(value: T, sourceHooks: OwnedSourceHooks): ReactiveNode<T> | undefined;
+    /**
+     * Читает материализованный signal и регистрирует зависимость активного
+     * потребителя.
+     * @internal
+     */
+    _readSignalNode<T>(node: ReactiveNode<T>): T;
+    /**
+     * Читает материализованный signal без подписки текущего потребителя;
+     * pending-значение фиксируется так же, как при обычном чтении.
+     * @internal
+     */
+    _peekSignalNode<T>(node: ReactiveNode<T>): T;
+    /**
+     * Возвращает значение, которое увидит следующее чтение: pending-значение
+     * незавершённой группировки либо зафиксированное. Ничего не фиксирует.
+     * @internal
+     */
+    _visibleSignalValue<T>(node: ReactiveNode<T>): T;
+    /**
+     * Записывает значение материализованного signal с обычной семантикой batch.
+     * @internal
+     */
+    _writeSignalNode<T>(node: ReactiveNode<T>, value: T): void;
+    /**
+     * Сообщает, есть ли у материализованного signal потребители в графе.
+     * @internal
+     */
+    _signalNodeHasSubscribers(node: ReactiveNode): boolean;
+    /**
+     * Отсоединяет материализованный signal от потребителей и освобождает его
+     * значения. Значения освобождаются и при сбое отсоединения. Поля pending
+     * сбрасываются, только если запись их получала: запись без группировок не
+     * меняет набор своих полей при освобождении.
+     * @internal
+     */
+    _releaseSignalNode(node: ReactiveNode): void;
+    /**
+     * Ищет среди текущих потребителей записи первого, чьего владельца принимает
+     * accept, и возвращает этого владельца. Владелец потребителя определяется
+     * так же, как при привязке ребра через onDependency: у computed это
+     * dependencyOwner его source hooks, у эффекта — dependencyOwner его задачи.
+     * Потребители без владельца пропускаются. Обход идёт в порядке списка
+     * потребителей, ничего не выделяет и не меняет граф; accept не должен менять
+     * связи этой записи.
+     * @param node Материализованная запись производителя.
+     * @param accept Проверка владельца потребителя; context передаётся ей без closure.
+     * @param context Произвольное значение вызывающего слоя для accept.
+     * @internal
+     */
+    _findSubscriberOwner<Context>(node: ReactiveNode, accept: (owner: object, context: Context) => boolean, context: Context): object | undefined;
+    /**
+     * Возвращает владельца активного потребителя: того, кому engine привязал бы
+     * ребро следующего отслеживаемого чтения. Владелец определяется так же, как
+     * в _findSubscriberOwner(). Без активного потребителя и у потребителя без
+     * владельца результат undefined. Метод ничего не выделяет и не меняет граф.
+     *
+     * Вызывающий слой проверяет по этому владельцу допустимость чтения, когда
+     * его собственный контекст снят, а потребитель engine остался активным.
+     * @internal
+     */
+    _activeSubscriberOwner(): object | undefined;
+    /**
+     * Увеличивает счётчик материализованного signal и уведомляет его
+     * потребителей. Без потребителей ничего не пишет и возвращает false.
+     *
+     * Сдвиг — обычная запись signal. Вне группировки она прямая: счётчик
+     * фиксируется сразу, а потребитель становится обязательным к пересчёту, в
+     * том числе тот, кто ждал только проверки зависимостей или стоит на стеке
+     * идущей проверки. Внутри группировки и у записи с ещё не прочитанным
+     * отложенным сдвигом запись откладывается до первого чтения, как любая запись
+     * внутри batch().
+     *
+     * Потребитель, который выполняется в момент прямого сдвига, получает его по
+     * общему правилу записи во время запуска: у записи не остаётся отложенного
+     * сдвига, который позже подтвердил бы ему изменение.
+     *
+     * Очередь эффектов обрабатывается на выходе, если группировки нет: отложенная
+     * запись сама её не обрабатывает, а потребитель, которого она поставила в
+     * очередь, не должен ждать следующей записи.
+     * @internal
+     */
+    _bumpSignalNode(node: ReactiveNode<number>): boolean;
+    /**
+     * Создаёт запись-счётчик для активного потребителя и связывает их; без
+     * потребителя возвращает undefined. Счётчик начинается с нуля и сдвигается
+     * через _bumpSignalNode().
+     *
+     * Счётчик — производитель без собственных зависимостей. Граф читает у него
+     * то же, что у записи signal в роли производителя: признаки, список
+     * потребителей, отсутствие getter, значение и source hooks. Полей списка
+     * зависимостей у записи нет, а hooks лежат в ней самой: счётчик стоит одной
+     * аллокации из шести полей, а запись signal с hooks — двух. Поля отложенной
+     * записи появляются у счётчика с первым сдвигом.
+     * @internal
+     */
+    _trackCounterNode(sourceHooks: OwnedSourceHooks): ReactiveNode<number> | undefined;
+    /**
+     * Возвращает постоянную задачу активного потребителя. Engine делает запись
+     * эффекта активным потребителем непосредственно перед вызовом её тела,
+     * поэтому первое обращение из тела возвращает задачу именно этого эффекта,
+     * какие бы доставки ни выполнил cleanup его прошлого запуска.
+     *
+     * Без активного потребителя и у потребителя без задачи — computed либо
+     * эффекта, созданного без внешнего планирования, — результат undefined.
+     * Метод ничего не выделяет и не меняет граф.
+     * @internal
+     */
+    _activeEffectTask(): EffectTask | undefined;
 }
 export declare const signal: RaphReactivity['signal'];
 export declare const reactive: RaphReactivity['reactive'];

package/dist/reactivity/scope.d.ts

@@ -1,13 +1,26 @@
+import { DisposalFailure } from './disposal';
 import { RaphReactivity } from './engine';
 import { Disposer, EffectCallback, OwnedResource, OwnedSource, ReadonlySignal, ScopeChildren, ScopeLink, Signal, SourceFinalizer, WatchCallback, WatchOptions, WatchSource, WritableComputedOptions } from './types';
 /**
- * Универсальный владелец ресурсов без фаз, путей и зависимости от Runtime.
- * Хранит ресурсы в двусвязном списке и освобождает их в обратном порядке.
- * Проверки lifetime выполняют только owned handles; свободные signal() не проходят
- * через владельца. Класс не является узлом графа зависимостей.
+ * Запись источника в списке владельца: сама хранит связь с соседом и сама
+ * освобождает источник, поэтому владельцу не нужна отдельная коллекция.
+ * @internal
  */
-export declare class ScopeNode {
-    readonly reactivity: RaphReactivity;
+export interface OwnedSourceEntry {
+    _previousSource: OwnedSourceEntry | undefined;
+    _finalizeSource: () => boolean;
+}
+/**
+ * Общая основа владельцев: список ресурсов, список источников и признаки
+ * lifetime лежат в самом владельце. ScopeNode добавляет standalone API,
+ * RaphScope — Runtime API; отдельного объекта-хранилища у владельца нет.
+ *
+ * Поля объявлены через `declare` и присваиваются в constructor в одном
+ * порядке: все владельцы одного класса получают один hidden class, а сборка с
+ * любым target не превращает объявления в вызовы field-helper.
+ * @internal
+ */
+export declare abstract class ScopeOwner implements ScopeChildren<OwnedResource> {
     /**
      * Первый зарегистрированный ресурс; не является ребёнком execution-дерева.
      * @internal
@@ -19,14 +32,11 @@ export declare class ScopeNode {
      */
     scopeLastChild: OwnedResource | undefined;
     private _resourceCount;
-    private _sourceFinalizers;
+    private _lastSource;
+    private _sourceCount;
     protected _disposed: boolean;
     protected _disposing: boolean;
-    /**
-     * Связывает владельца с реактивным экземпляром без создания нового графа.
-     * @param reactivity Экземпляр, в котором создаются owned-ресурсы.
-     */
-    constructor(reactivity: RaphReactivity);
+    constructor();
     /**
      * Показывает, началось ли окончательное освобождение владельца.
      */
@@ -35,6 +45,88 @@ export declare class ScopeNode {
      * Разрешает регистрацию и доступ только до начала освобождения.
      */
     get active(): boolean;
+    /**
+     * Возвращает число ещё не освобождённых записей ресурсов.
+     * @internal
+     */
+    _debugResourceCount(): number;
+    /**
+     * Возвращает число зарегистрированных источников; после начала их
+     * финализации владелец источников не числит.
+     * @internal
+     */
+    _debugSourceCount(): number;
+    /**
+     * Возвращает последний зарегистрированный источник: с него по связям
+     * `_previousSource` обходится список источников владельца от нового к
+     * старому. С началом финализации владелец источников не числит, и метод
+     * возвращает undefined. Обход не должен регистрировать и освобождать
+     * источники этого владельца.
+     * @internal
+     */
+    _lastOwnedSource(): OwnedSourceEntry | undefined;
+    /**
+     * Вынимает запись ресурса из списка владельца и уменьшает счётчик. Запись
+     * вызывает метод из своего dispose() до пользовательского cleanup, иначе
+     * освобождение владельца не продвинется по списку. Повторный вызов и запись
+     * другого владельца безопасно игнорируются.
+     * @internal
+     */
+    _releaseRecord(entry: OwnedResource): void;
+    /**
+     * Ставит cleanup в конец списка ресурсов и возвращает его однократный stop.
+     * Lifetime не проверяет: это делает вызывающий метод владельца.
+     *
+     * Stop захватывает только запись, а не владельца: снятая запись теряет ссылку
+     * на владельца, поэтому удержанный stop не удерживает ни его, ни соседние
+     * записи.
+     */
+    protected _ownCleanup(cleanup: Disposer): Disposer;
+    /** Registers a framework cleanup; the public stop still exposes only raw failure. */
+    protected _ownCompleted(cleanup: () => DisposalFailure | undefined): Disposer;
+    /**
+     * Ставит готовую запись ресурса в конец списка без обёртки и closure: запись
+     * сама является элементом списка владельца. Её dispose() обязан сначала
+     * вызвать _releaseRecord(), иначе освобождение владельца не продвинется по
+     * списку. Предусловие: запись не состоит в другом списке.
+     * Lifetime не проверяет: это делает вызывающий метод владельца.
+     */
+    protected _ownRecord(entry: OwnedResource): void;
+    /**
+     * Ставит функцию-финализатор источника в список источников владельца.
+     * Lifetime не проверяет: это делает вызывающий метод владельца.
+     */
+    protected _ownSourceFinalizer(finalizer: SourceFinalizer): void;
+    /**
+     * Ставит готовую запись источника в список источников владельца без обёртки:
+     * источник сам является элементом списка и сам освобождает себя через
+     * _finalizeSource(). Предусловие: запись не состоит в другом списке.
+     * Lifetime не проверяет: это делает вызывающий метод владельца.
+     */
+    protected _ownSourceEntry(entry: OwnedSourceEntry): void;
+    /**
+     * Освобождает ресурсы в обратном порядке регистрации, затем финализирует
+     * источники. Сбой одной записи не останавливает остальные; массив ошибок
+     * создаётся только при первой ошибке.
+     */
+    protected _releaseOwned(): DisposalFailure[] | undefined;
+}
+/**
+ * Универсальный владелец ресурсов без фаз, путей и зависимости от Runtime.
+ * Хранит ресурсы в двусвязном списке и освобождает их в обратном порядке.
+ * Проверки lifetime выполняют только owned handles; свободные signal() не проходят
+ * через владельца. Класс не является узлом графа зависимостей.
+ */
+export declare class ScopeNode extends ScopeOwner {
+    /**
+     * Экземпляр, в котором создаются owned-ресурсы.
+     */
+    readonly reactivity: RaphReactivity;
+    /**
+     * Связывает владельца с реактивным экземпляром без создания нового графа.
+     * @param reactivity Экземпляр, в котором создаются owned-ресурсы.
+     */
+    constructor(reactivity: RaphReactivity);
     /**
      * Создаёт owned signal и регистрирует его финализатор.
      * Все методы возвращённого handle проверяют, что владелец ещё активен.
@@ -62,16 +154,6 @@ export declare class ScopeNode {
      * Если владелец уже неактивен, выполняет cleanup сразу и возвращает пустой disposer.
      */
     own(disposer: Disposer): Disposer;
-    /**
-     * Возвращает число ещё не освобождённых записей ресурсов.
-     * @internal
-     */
-    _debugResourceCount(): number;
-    /**
-     * Возвращает число зарегистрированных финализаторов источников.
-     * @internal
-     */
-    _debugSourceCount(): number;
     /**
      * Освобождает ресурсы в обратном порядке, затем финализирует источники.
      * Повторный вызов безопасен. Ошибки cleanup и завершающего hook собираются
@@ -100,6 +182,8 @@ export declare class ScopeNode {
     /**
      * Добавляет финализатор источника. Возвращённый им false означает повторную попытку
      * после прогресса других финализаторов, а не успешное освобождение.
+     * Каждая регистрация — отдельный источник: одинаковые финализаторы владелец
+     * не объединяет, и функция, переданная дважды, будет вызвана дважды.
      * @internal
      */
     _ownSource(finalizer: SourceFinalizer): void;
@@ -118,17 +202,11 @@ export declare class ScopeNode {
      * Возвращает сообщение для AggregateError при нескольких ошибках освобождения.
      */
     protected _disposalMessage(): string;
-    /**
-     * Освобождает источники в обратном порядке регистрации с повторными попытками.
-     * Если в проходе не было прогресса, прекращает обход, сохраняя существующий контракт.
-     * Исключение одного финализатора не блокирует остальные.
-     */
-    private _finalizeSources;
 }
 /**
  * Добавляет дочерний ресурс в конец списка владельца без отдельной обёртки связей.
- * Предусловие: ребёнок ещё не находится в другом списке. Переиспользуется
- * ресурсами ScopeNode и записями вложенных эффектов.
+ * Предусловие: ребёнок ещё не находится в другом списке. Используется записями
+ * вложенных эффектов; владельцы ведут свой список ресурсов сами.
  * @internal
  */
 export declare function appendScopeChild<T extends ScopeLink<T>>(parent: ScopeChildren<T>, child: T): void;