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

package/dist/reactivity/engine.d.ts

@@ -1,559 +1,15 @@
-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';
-/**
- * Изолированный граф реактивности с синхронным исполнением по умолчанию.
- * Состояние принадлежит полям экземпляра, алгоритмы - обычным методам прототипа.
- * Только передаваемые наружу методы связаны с экземпляром один раз; очередь
- * синхронного движка не проверяет внешнюю политику на каждом эффекте.
- */
-export declare class RaphReactivity {
-    private readonly adaptiveDependencyIndex;
-    private activeSub;
-    private batchDepth;
-    private effectReadIndex;
-    private effectWriteIndex;
-    private invalidationDepth;
-    private dependencyDepth;
-    private checkingDepth;
-    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 Необязательная внешняя политика эффектов.
-     */
+import { ReactivityOptions, ReadonlySignal, Signal, WritableComputedOptions } from './types.js';
+import { ReactivityEngine } from './engine-core.js';
+export { ScopeNode } from './scope.js';
+export type { Disposer, EffectCallback, EffectScheduler, EffectTask, ReactivityOptions, ReadonlySignal, Signal, WatchCallback, WatchOptions, WatchSource, WatchValue, WritableComputedOptions, } from './types.js';
+/** Прежний standalone API; общий signal graph не зависит от Proxy adapter. */
+export declare class RaphReactivity extends ReactivityEngine {
     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;
-    /**
-     * Возвращает кеш либо синхронно актуализирует вычисляемое значение.
-     * Неуспешное вычисление не считается значением. Ошибка getter сохраняет связь
-     * с активным потребителем для восстановления. Повторное чтение во время
-     * первого сбора зависимостей отклоняется до регистрации связи и чтения кеша.
-     */
-    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 обозначает границу прочитанного префикса, а не неизменный конец списка.
-     * Ошибка cleanup не прерывает освобождение оставшегося хвоста зависимостей.
-     */
-    private pruneUnreadDependencies;
-    /**
-     * Удаляет связь только из списка потребителей производителя.
-     * Список зависимостей потребителя и его счётчик здесь не изменяются.
-     * Также исправляет курсор поиска, если он указывал на удаляемую связь.
-     */
-    private detachSubLink;
-    /** Завершает удаление producer-связи без вызова source cleanup. */
-    private unlinkSubLink;
-    /** 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;
-    private markActiveChecks;
-    /**
-     * Помечает работающего потребителя, только если затронута уже прочитанная связь.
-     * Связи за trackedTail принадлежат прошлому запуску и не означают повторную invalidation.
-     * @returns Новое состояние либо ноль, если уведомление не требуется.
-     */
-    private invalidateReadDependency;
-    /**
-     * Подтверждает необходимость пересчёта непосредственных потребителей.
-     * Применяется после фиксации реально изменившегося значения; позволяет исключить
-     * текущую связь и автора записи.
-     */
-    private confirmSubUpdates;
-    /**
-     * Повторно вычисляет узел, согласует зависимости и сравнивает результат с кешем.
-     * При ошибке восстанавливает контекст, удаляет непрочитанный хвост и оставляет
-     * повторяемое состояние ошибки. Также восстанавливает непосредственного потребителя
-     * skipSub: при разворачивании стека его связь могла быть уже извлечена из буфера.
-     * Неверное значение в кеш не записывается.
-     */
-    private recomputeValue;
-    /** Сохраняет первичную ошибку и отдельные ошибки cleanup при восстановлении. */
-    private failComputedValue;
-    /**
-     * Восстанавливает связи и состояния после неудачного 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;
-    private markRecoveryDependencies;
-    /**
-     * Завершает очередь после первой ошибки, собирая последующие причины сбоя.
-     * Вызывается только на ошибочном пути; успешный проход не создаёт массив ошибок
-     * и не устанавливает отдельный 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;
-    /**
-     * Создаёт запись графа для эффекта с внешним планированием и подключает его
-     * постоянную задачу. Запуск ещё не запрошен: вызывающий слой сохраняет запись
-     * и затем вызывает _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'];