@raphy-js/raph 1.0.0-dev.18

package/dist/reactivity/engine.d.ts

@@ -0,0 +1,393 @@
+import { ComputedAccessHandle, Disposer, EffectCallback, EffectFactory, OwnedSource, OwnedSourceHooks, 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';
+/**
+ * Изолированный граф реактивности с синхронным исполнением по умолчанию.
+ * Состояние принадлежит полям экземпляра, алгоритмы - обычным методам прототипа.
+ * Только передаваемые наружу методы связаны с экземпляром один раз; очередь
+ * синхронного движка не проверяет внешнюю политику на каждом эффекте.
+ */
+export declare class RaphReactivity {
+    private readonly adaptiveDependencyIndex;
+    private activeSub;
+    private batchDepth;
+    private effectReadIndex;
+    private effectWriteIndex;
+    private invalidationDepth;
+    private dependencyDepth;
+    private flushingEffects;
+    private readonly effectQueue;
+    private readonly invalidationStack;
+    private readonly dependencyStack;
+    private readonly handleReaders;
+    private readonly effectScheduler;
+    private readonly flushEffects;
+    /**
+     * Синхронная регистрация эффекта для Runtime и watch независимо от внешней политики.
+     * Это связанная ссылка на реализацию effect(), а не делегирующая функция.
+     * @internal
+     */
+    readonly _effectImmediate: EffectFactory;
+    /**
+     * Выбирает политику исполнения и сохраняет совместимость извлечённых методов.
+     * Тела методов находятся на прототипе; bind() выполняется только при создании
+     * экземпляра, чтобы Runtime и глобальный API могли передавать методы как callbacks.
+     * @param options Необязательная внешняя политика эффектов.
+     */
+    constructor(options?: ReactivityOptions);
+    /**
+     * Создаёт объектный signal с get/peek/set.
+     * get() регистрирует зависимость только при активном потребителе,
+     * а peek() выполняет чтение с временно отключённым отслеживанием.
+     */
+    signal<T>(initialValue: T): Signal<T>;
+    /**
+     * Возвращает стабильный глубокий Proxy для plain object или array.
+     * Object context и per-property sources создаются лениво внутри этого engine.
+     */
+    reactive<T extends object>(value: T): T;
+    /**
+     * - `(1)` Создаёт ленивое вычисляемое значение только для чтения;
+     * - `(2)` Создаёт writable computed, сохраняя исходную функцию setter;
+     * - `(3)` Создаёт ленивое вычисляемое значение; для объекта get/set сохраняет;
+     * исходную функцию записи без дополнительной обёртки.
+     */
+    computed<T>(getter: () => T): ReadonlySignal<T>;
+    computed<T>(options: WritableComputedOptions<T>): Signal<T>;
+    /**
+     * Создаёт эффект согласно политике экземпляра и возвращает disposer.
+     * Прототип содержит синхронную реализацию; при наличии scheduler конструктор
+     * подставляет createScheduledEffect, сохраняя этот путь как _effectImmediate.
+     * Вложенный эффект включается в список ресурсов активного эффекта.
+     * При ошибке регистрации удаляет созданные ресурсы, сохраняя обе причины сбоя.
+     * @param fn Синхронное тело с необязательным cleanup очередного запуска.
+     * @param onStop Однократная окончательная очистка, независимая от повторных запусков.
+     */
+    effect(fn: EffectCallback, onStop?: Disposer): Disposer;
+    /**
+     * Наблюдает за источниками; callback и cleanup не создают зависимостей.
+     */
+    watch<S extends WatchSource | readonly WatchSource[]>(source: S, callback: WatchCallback<S>, options?: WatchOptions): Disposer;
+    /**
+     * Группирует синхронные записи и обрабатывает эффекты после внешней границы.
+     * Возвращает результат операции. Если тело и очередь завершаются с ошибками,
+     * передаёт обе ошибки в AggregateError вместо потери первой. Не является откатом данных.
+     */
+    batch<T>(fn: () => T): T;
+    /**
+     * Выполняет синхронную операцию без добавления зависимостей текущему потребителю.
+     * Восстанавливает прежний контекст и при исключении. Асинхронное продолжение
+     * операции этим контекстом не охватывается.
+     */
+    untracked<T>(fn: () => T): T;
+    /**
+     * Создаёт владельца ресурсов в текущем графе без Runtime и фаз.
+     */
+    scope(): ScopeNode;
+    /**
+     * Создаёт запись графа с одинаковым порядком основных полей.
+     * Значение служит кешем signal/computed либо хранит cleanup эффекта.
+     * Поля внешней задачи и окончательной очистки добавляются только при необходимости.
+     */
+    private allocateGraphRecord;
+    /** Creates a narrow Proxy adapter over the existing intrusive graph. */
+    private createReactivePropertySourceBridge;
+    /**
+     * Материализует signal в графе при первом отслеживаемом чтении
+     * и связывает его с активным потребителем.
+     *
+     * До этого момента signal может хранить значение только в замыкании
+     * и вообще не создавать `ReactiveNode`.
+     */
+    private materializeSignal;
+    /**
+     * Создаёт минимальный handle computed без преждевременного выделения полей графа.
+     * Первый get() материализует запись на этом же объекте и заменяет метод чтения.
+     */
+    private createComputedHandle;
+    /**
+     * Создаёт эффект с одной постоянной задачей внешнего scheduler.
+     * Первый и последующие запуски проходят через задачу; устаревший runner после stop
+     * ничего не выполняет. При синхронной ошибке runner обрабатывает независимую очередь.
+     * @param fn Тело эффекта.
+     * @param onStop Однократная окончательная очистка.
+     */
+    private createScheduledEffect;
+    /**
+     * Регистрирует чтение signal и при необходимости фиксирует pending-значение.
+     * Текущая связь передаётся фиксации, чтобы не уведомлять читающего потребителя повторно.
+     */
+    private readSignalValue;
+    /**
+     * Записывает новое значение или откладывает его фиксацию до чтения в batch.
+     * Сохраняет исходное сравнение через === и учёт автора pending-записи.
+     * Без batch и внешней политики очередь эффектов завершается до возврата из set().
+     */
+    private writeSignalValue;
+    /**
+     * Возвращает кеш либо синхронно актуализирует вычисляемое значение.
+     * Неуспешное вычисление не считается значением. Даже ошибочное чтение сохраняет
+     * связь с активным потребителем, чтобы тот мог восстановиться при изменении источника.
+     */
+    private readComputedValue;
+    /**
+     * Выполняет первый сбор зависимостей и кеширует только успешный результат.
+     * При исключении оставляет состояние повторяемой ошибки, а не чистый undefined.
+     * Уже прочитанные зависимости сохраняются для последующего уведомления.
+     */
+    private evaluateFirstValue;
+    /**
+     * Актуализирует computed: выполняет прямой пересчёт либо проверяет зависимости.
+     * После ошибки getter разрешён повторный пересчёт даже без новой записи источника.
+     */
+    private refreshComputedValue;
+    /**
+     * Фиксирует pending-значение и уведомляет непосредственных потребителей.
+     * Пропускает указанную связь и автора записи, чтобы не дублировать текущую работу.
+     * @returns Изменилось ли зафиксированное значение.
+     */
+    private commitSignalValue;
+    /**
+     * Обрабатывает чтение производителя активным потребителем.
+     * Сначала проверяет текущую и следующую связи; более дорогой поиск вынесен отдельно.
+     */
+    private trackDependency;
+    /**
+     * Согласует чтение с существующим списком зависимостей при несовпадении порядка.
+     * Использует ограниченный линейный поиск, затем поиск среди потребителей производителя.
+     * Существующую связь перемещает или переиспользует; новую создаёт только при необходимости.
+     */
+    private reconcileDependency;
+    /**
+     * Добавляет связь при первоначальном сборе зависимостей.
+     * Предусловие: after является хвостом собранного префикса нового списка.
+     * Связь одновременно включается в список потребителей производителя.
+     */
+    private appendInitialDependency;
+    /**
+     * Вставляет связь после заданного курсора зависимостей потребителя.
+     * Сохраняет ещё не прочитанный хвост списка и увеличивает dependencyCount.
+     */
+    private insertDependency;
+    /**
+     * Переназначает существующую связь другому производителю.
+     * Положение в списке зависимостей потребителя и число его связей сохраняются.
+     */
+    private reuseDepLink;
+    /**
+     * Перемещает существующую зависимость после курсора текущего чтения.
+     * Список потребителей производителя и количество зависимостей не изменяет.
+     */
+    private reorderDependency;
+    /**
+     * Удаляет непрочитанный хвост зависимостей завершившегося запуска.
+     * trackedTail обозначает границу прочитанного префикса, а не неизменный конец списка.
+     * Удаление из списков производителей не выполняет пользовательские callbacks.
+     */
+    private pruneUnreadDependencies;
+    /**
+     * Удаляет связь только из списка потребителей производителя.
+     * Список зависимостей потребителя и его счётчик здесь не изменяются.
+     * Также исправляет курсор поиска, если он указывал на удаляемую связь.
+     */
+    private detachSubLink;
+    /** Connects Runtime ownership metadata only for edges whose producer opted in. */
+    private attachDependencyCleanup;
+    /**
+     * Отсоединяет owned-источник сразу с обеих сторон каждой связи.
+     * Вызывается на границе lifetime, а не при обычных чтениях и записях.
+     * Переводит ожидавших проверку потребителей к повторному вычислению при необходимости.
+     */
+    private releaseSourceSubs;
+    /**
+     * Удаляет связь только из списка зависимостей потребителя.
+     * Исправляет курсор прочитанного префикса и dependencyCount; список производителя
+     * должен быть обновлён отдельной операцией.
+     */
+    private detachDependencyLink;
+    /**
+     * Добавляет эффект во внутреннюю очередь один раз до обработки текущей записи.
+     * Флаг SCHEDULED предотвращает повторное добавление без создания task-объекта.
+     */
+    private enqueueEffect;
+    /**
+     * Распространяет invalidation от непосредственных к транзитивным потребителям.
+     * Сохраняет исходный итеративный обход с переиспользуемым стеком; callbacks
+     * не выполняет. Непосредственное и потенциальное изменения отмечает разными флагами.
+     */
+    private propagateInvalidation;
+    /**
+     * Помечает работающего потребителя, только если затронута уже прочитанная связь.
+     * Связи за trackedTail принадлежат прошлому запуску и не означают повторную invalidation.
+     * @returns Новое состояние либо ноль, если уведомление не требуется.
+     */
+    private invalidateReadDependency;
+    /**
+     * Подтверждает необходимость пересчёта непосредственных потребителей.
+     * Применяется после фиксации реально изменившегося значения; позволяет исключить
+     * текущую связь и автора записи.
+     */
+    private confirmSubUpdates;
+    /**
+     * Повторно вычисляет узел, согласует зависимости и сравнивает результат с кешем.
+     * При ошибке восстанавливает контекст, удаляет непрочитанный хвост и оставляет
+     * повторяемое состояние ошибки. Также восстанавливает непосредственного потребителя
+     * skipSub: при разворачивании стека его связь могла быть уже извлечена из буфера.
+     * Неверное значение в кеш не записывается.
+     */
+    private recomputeValue;
+    /**
+     * Восстанавливает связи и состояния после неудачного getter.
+     * Отдельная функция удерживает обработку исключений вне обычной части пересчёта.
+     * Потребитель исключаемой связи мог уже покинуть активный префикс стека.
+     */
+    private restoreComputedFailure;
+    /**
+     * Итеративно проверяет зависимые computed и pending-сигналы перед запуском потребителя.
+     * Использует общий стек с сохранением активного префикса вложенного обхода.
+     * При исключении восстанавливает высоту стека и состояния всех незавершённых
+     * узлов текущего прохода; порядок успешного обхода не меняется.
+     */
+    private refreshDependencies;
+    /** Settles every direct dependency so a cancelled external delivery can be re-armed. */
+    private settleCancelledDependencies;
+    /**
+     * Выполняет исходный итеративный обход зависимостей без обработки ошибок внутри цикла.
+     * Перед пользовательским вычислением публикует активную высоту стека; оболочка
+     * refreshDependencies() использует этот префикс для восстановления после сбоя.
+     */
+    private walkDependencyChain;
+    /**
+     * Восстанавливает незавершённую запись после прерванной проверки зависимостей.
+     * Computed получает повторяемое состояние ошибки, effect остаётся доступным
+     * для следующей invalidation. Вызывается только на ошибочном пути.
+     */
+    private restoreFailedDependency;
+    /**
+     * Проверяет необходимость запуска, очищает прошлые ресурсы и выполняет тело эффекта.
+     * Ошибка cleanup останавливает эффект до создания ресурсов следующего запуска.
+     * При ошибке тела сохраняет фактически прочитанные зависимости, останавливает
+     * созданных детей и разрешает повторный запуск после следующей записи.
+     * Cleanup, возвращённый после собственного stop, освобождается сразу.
+     */
+    private executeEffect;
+    /**
+     * Завершает неудачный запуск эффекта, не затрагивая успешный путь исполнения.
+     * Сохраняет прочитанные зависимости для следующей invalidation, освобождает
+     * детей неудачного запуска и объединяет ошибки с предыдущими ошибками cleanup.
+     */
+    private failEffectRun;
+    /**
+     * Обрабатывает синхронную очередь до исчерпания, включая добавленную во время прохода работу.
+     * Ошибки отдельных эффектов не блокируют соседей и передаются после обработки.
+     * Путь не проверяет наличие внешней задачи у каждого узла.
+     */
+    private flushSyncEffects;
+    /**
+     * Обрабатывает очередь экземпляра с внешней политикой выполнения.
+     * Обычные внутренние эффекты выполняет сразу, остальные передаёт постоянной задаче.
+     * Ошибка одного элемента не оставляет необработанные записи со старым SCHEDULED.
+     */
+    private flushExternalEffects;
+    /**
+     * Завершает очередь после первой ошибки, собирая последующие причины сбоя.
+     * Вызывается только на ошибочном пути; успешный проход не создаёт массив ошибок
+     * и не устанавливает отдельный catch для каждого элемента.
+     */
+    private drainQueueAfterError;
+    /**
+     * Передаёт эффект его постоянной внешней задаче.
+     * Если schedule() бросает исключение, снимает незавершённую invalidation,
+     * чтобы последующая запись могла снова запросить выполнение.
+     */
+    private requestEffectTask;
+    private scheduleEffectTask;
+    /**
+     * Окончательно останавливает эффект и освобождает все принадлежащие ему ресурсы.
+     * Сначала делает узел неактивным и отсоединяет связи, затем отменяет задачу,
+     * останавливает детей, выполняет cleanup и onStop. Каждая стадия завершается
+     * несмотря на ошибки соседних стадий; повторный или вложенный stop безопасен.
+     */
+    private disposeEffect;
+    /**
+     * Останавливает все вложенные эффекты в обратном порядке регистрации.
+     * Всегда берёт актуальный хвост: cleanup может удалить другого ребёнка.
+     * Передаёт собранные ошибки только после освобождения всех детей.
+     */
+    private disposeNestedEffects;
+    /**
+     * Задаёт обязательные поля графа перед первым вычислением.
+     * Вызывается только для нематериализованного handle; getter и контекст сохраняются.
+     */
+    private static materializeComputed;
+    /**
+     * Связывает два разных receiver: движок-владелец и читаемый handle.
+     * Эти четыре общие функции адаптируют this; алгоритмы чтения остаются методами
+     * RaphReactivity. Адаптеры создаются один раз на граф, а не на каждое вычисление.
+     */
+    private createHandleReaders;
+    /**
+     * Читает handle без подписки текущего потребителя, сохраняя receiver get().
+     * Прежний контекст восстанавливается и после исключения getter.
+     */
+    private peekHandle;
+    /**
+     * Создаёт единый низкоуровневый read/write accessor для core-дорожки Bench Lab.
+     * Публичный объектный API остаётся отдельным и измеряется в API-tax.
+     * @internal
+     */
+    _signalAccess<T>(initialValue: T): SignalAccess<T>;
+    /**
+     * Создаёт нематериализованный computed для низкоуровневого read API.
+     * Графовые поля появляются при первом чтении; тип описывает обе стадии.
+     * @internal
+     */
+    _computedAccess<T>(fn: () => T): ComputedAccessHandle<T>;
+    /**
+     * Создаёт signal, жизненным циклом которого управляет `ScopeNode`.
+     *
+     * Реактивная логика совпадает с обычным `signal()`, но disposer
+     * дополнительно отсоединяет материализованный источник от графа.
+     *
+     * @internal
+     */
+    _ownedSignal<T>(initialValue: T, sourceHooks?: OwnedSourceHooks): OwnedSource<Signal<T>>;
+    /**
+     * Создаёт ленивый computed с финализатором исходящих и входящих связей.
+     * Финализатор работает и до первого вычисления, не материализуя узел ради очистки.
+     * @internal
+     */
+    _ownedComputed<T>(fn: () => T, sourceHooks?: OwnedSourceHooks): OwnedSource<ReadonlySignal<T>>;
+    /**
+     * Открывает вложенную синхронную границу группировки.
+     * Внутренний вызывающий код обязан выполнить соответствующий endBatch().
+     * @internal
+     */
+    _startBatch(): void;
+    /**
+     * Закрывает ранее открытую границу и обрабатывает очередь на внешнем уровне.
+     * Предусловие: число закрытий не должно превышать число открытий.
+     * @internal
+     */
+    _endBatch(): void;
+    /**
+     * Проверяет наличие активного потребителя в текущем синхронном стеке чтения.
+     * @internal
+     */
+    _isTracking(): boolean;
+    /**
+     * Показывает, обрабатывает ли экземпляр внутреннюю очередь эффектов.
+     * @internal
+     */
+    _isFlushingEffects(): boolean;
+}
+export declare const signal: RaphReactivity['signal'];
+export declare const reactive: RaphReactivity['reactive'];
+export declare function computed<T>(getter: () => T): ReadonlySignal<T>;
+export declare function computed<T>(options: WritableComputedOptions<T>): Signal<T>;
+export declare const effect: RaphReactivity['effect'];
+export declare const watch: RaphReactivity['watch'];
+export declare const batch: RaphReactivity['batch'];
+export declare const untracked: RaphReactivity['untracked'];
+export declare const scope: RaphReactivity['scope'];

package/dist/reactivity/reactive-object.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Opaque per-property producer used by the reactive-object adapter.
+ * The concrete record belongs to RaphReactivity's existing intrusive graph.
+ * @internal
+ */
+export type ReactivePropertySource = object;
+/**
+ * The only bridge between Proxy bookkeeping and the reactive graph internals.
+ * It deliberately exposes operations instead of graph fields or subclass hooks.
+ * @internal
+ */
+export interface ReactivePropertySourceBridge {
+    readonly batch: <T>(operation: () => T) => T;
+    readonly create: () => ReactivePropertySource;
+    readonly isTracking: () => boolean;
+    readonly track: (source: ReactivePropertySource) => void;
+    readonly trigger: (source: ReactivePropertySource) => void;
+}
+/** Runtime policy installed for one RuntimeReactivity instance. @internal */
+export interface ReactiveObjectPolicy {
+    readonly owner?: object;
+    readonly assertRead?: () => void;
+    readonly assertWrite?: () => void;
+    readonly runWrite?: <T>(operation: () => T) => T;
+    readonly throwForeign?: (owner: object | undefined) => never;
+}
+/** Associates Runtime lifecycle policy with an engine without widening its public class API. @internal */
+export declare function configureReactiveObjectPolicy(engine: object, policy: ReactiveObjectPolicy): void;
+/** Releases a Runtime-owned context while retained proxies become inert handles. @internal */
+export declare function disposeReactiveObjectContext(engine: object, disposedPolicy?: ReactiveObjectPolicy): void;
+/**
+ * Returns one stable Proxy per raw object inside one RaphReactivity instance.
+ * The context and both WeakMaps are allocated only after the first call.
+ * @internal
+ */
+export declare function reactiveObject<T extends object>(engine: object, value: T, createBridge: () => ReactivePropertySourceBridge): T;

package/dist/reactivity/scope.d.ts

@@ -0,0 +1,146 @@
+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() не проходят
+ * через владельца. Класс не является узлом графа зависимостей.
+ */
+export declare class ScopeNode {
+    readonly reactivity: RaphReactivity;
+    /**
+     * Первый зарегистрированный ресурс; не является ребёнком execution-дерева.
+     * @internal
+     */
+    scopeFirstChild: OwnedResource | undefined;
+    /**
+     * Последний ресурс, с которого начинается освобождение владельца.
+     * @internal
+     */
+    scopeLastChild: OwnedResource | undefined;
+    private _resourceCount;
+    private _sourceFinalizers;
+    protected _disposed: boolean;
+    protected _disposing: boolean;
+    /**
+     * Связывает владельца с реактивным экземпляром без создания нового графа.
+     * @param reactivity Экземпляр, в котором создаются owned-ресурсы.
+     */
+    constructor(reactivity: RaphReactivity);
+    /**
+     * Показывает, началось ли окончательное освобождение владельца.
+     */
+    get disposed(): boolean;
+    /**
+     * Разрешает регистрацию и доступ только до начала освобождения.
+     */
+    get active(): boolean;
+    /**
+     * Создаёт owned signal и регистрирует его финализатор.
+     * Все методы возвращённого handle проверяют, что владелец ещё активен.
+     */
+    signal<T>(value: T): Signal<T>;
+    /**
+     * Создаёт owned computed только для чтения.
+     */
+    computed<T>(getter: () => T): ReadonlySignal<T>;
+    /**
+     * Создаёт owned writable computed с очисткой getter и setter.
+     */
+    computed<T>(options: WritableComputedOptions<T>): Signal<T>;
+    /**
+     * Создаёт эффект и принимает его disposer во владение.
+     * Если владелец уничтожен во время синхронного запуска, немедленно останавливает эффект.
+     */
+    effect(callback: EffectCallback): Disposer;
+    /**
+     * Создаёт watch и регистрирует окончательную остановку у владельца.
+     */
+    watch<S extends WatchSource | readonly WatchSource[]>(source: S, callback: WatchCallback<S>, options?: WatchOptions): Disposer;
+    /**
+     * Принимает произвольный cleanup и возвращает однократный disposer.
+     * Если владелец уже неактивен, выполняет cleanup сразу и возвращает пустой disposer.
+     */
+    own(disposer: Disposer): Disposer;
+    /**
+     * Возвращает число ещё не освобождённых записей ресурсов.
+     * @internal
+     */
+    _debugResourceCount(): number;
+    /**
+     * Возвращает число зарегистрированных финализаторов источников.
+     * @internal
+     */
+    _debugSourceCount(): number;
+    /**
+     * Освобождает ресурсы в обратном порядке, затем финализирует источники.
+     * Повторный вызов безопасен. Ошибки cleanup и завершающего hook собираются
+     * и передаются только после завершения остальных стадий.
+     */
+    dispose(): void;
+    /**
+     * Регистрирует ресурс только у активного владельца.
+     * Дочерняя запись отсоединяется до вызова cleanup, включая ошибочный и вложенный stop.
+     * В отличие от own(), не принимает регистрацию после dispose.
+     * @internal
+     */
+    _own(disposer: Disposer): Disposer;
+    /**
+     * Принимает уже созданный ресурс и не оставляет его без владельца при ошибке регистрации.
+     * При неудачной очистке сохраняет и ошибку регистрации, и ошибку освобождения.
+     * @internal
+     */
+    _adoptResource(disposer: Disposer): Disposer;
+    /**
+     * Регистрирует финализатор owned-источника и возвращает его handle.
+     * Если владелец уже недоступен, освобождает источник до передачи ошибки.
+     * @internal
+     */
+    _adoptSource<T>(owned: OwnedSource<T>): T;
+    /**
+     * Добавляет финализатор источника. Возвращённый им false означает повторную попытку
+     * после прогресса других финализаторов, а не успешное освобождение.
+     * @internal
+     */
+    _ownSource(finalizer: SourceFinalizer): void;
+    /**
+     * Запрещает операции после начала освобождения владельца.
+     * Текст существующей ошибки сохранён для совместимости вызывающих слоёв.
+     * @internal
+     */
+    _assertAlive(): void;
+    /**
+     * Завершающий hook для наследников после ресурсов и источников.
+     * Базовая реализация ничего не делает; исключение наследника попадёт в общий результат.
+     */
+    protected _afterDispose(): void;
+    /**
+     * Возвращает сообщение для AggregateError при нескольких ошибках освобождения.
+     */
+    protected _disposalMessage(): string;
+    /**
+     * Освобождает источники в обратном порядке регистрации с повторными попытками.
+     * Если в проходе не было прогресса, прекращает обход, сохраняя существующий контракт.
+     * Исключение одного финализатора не блокирует остальные.
+     */
+    private _finalizeSources;
+}
+/**
+ * Добавляет дочерний ресурс в конец списка владельца без отдельной обёртки связей.
+ * Предусловие: ребёнок ещё не находится в другом списке. Переиспользуется
+ * ресурсами ScopeNode и записями вложенных эффектов.
+ * @internal
+ */
+export declare function appendScopeChild<T extends ScopeLink<T>>(parent: ScopeChildren<T>, child: T): void;
+/**
+ * Отсоединяет ребёнка от владельца и обнуляет его связи со списком.
+ * Повторное отсоединение безопасно; пользовательский cleanup здесь не вызывается.
+ * @internal
+ */
+export declare function detachScopeChild<T extends ScopeLink<T>>(node: T): void;
+/**
+ * Передаёт единственную ошибку без обёртки либо несколько причин в AggregateError.
+ * Пустой набор не вызывает исключения.
+ * @internal
+ */
+export declare function throwScopeErrors(errors: readonly unknown[], message: string): void;