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

package/dist/runtime/reactivity/RaphSelector.d.ts

@@ -0,0 +1,338 @@
+import { OwnedSourceEntry } from '../../reactivity/scope';
+import { RaphScope } from '../ownership/RaphScope';
+import { RuntimeDisposalSweeper, RuntimeSignalWriteTap } from './runtime-reactivity.types';
+import { RuntimeReactivity, RuntimeSignal } from './RuntimeReactivity';
+/**
+ * Настройки selector.
+ *
+ * @typeParam Key — тип ключа и значения source.
+ */
+export interface RaphSelectorOptions<Key> {
+    /**
+     * Сравнение ключа со значением source вместо SameValueZero. Функция должна
+     * быть чистой: один и тот же ответ для одной пары аргументов и никаких
+     * чтений реактивных источников. С ней запись в source сравнивает каждый
+     * наблюдаемый ключ с прежним и с новым значением и будит только те ключи,
+     * чей ответ изменился.
+     */
+    readonly equals?: (key: Key, value: Key) => boolean;
+}
+/**
+ * Чтение selector: сообщает, совпадает ли ключ с текущим значением source, и
+ * подписывает активного потребителя только на этот ключ.
+ *
+ * @typeParam Key — тип ключа и значения source.
+ */
+export type RaphSelector<Key> = (key: Key) => boolean;
+/**
+ * Компактное описание selector, которое возвращает его toJSON().
+ *
+ * @internal
+ */
+export interface RuntimeSelectorDescription {
+    readonly owner: string;
+    readonly triggers: number;
+    readonly disposed: boolean;
+}
+/**
+ * Selector одним объектом: запись в списке источников владельца, наблюдатель
+ * записей source, индекс triggers по ключам и участник уборки Runtime.
+ *
+ * Trigger ключа — запись-счётчик графа: потребитель, прочитавший ключ,
+ * зависит только от неё, а не от source. Запись в source
+ * сдвигает счётчики triggers прежнего и нового ключа, и будятся только их
+ * потребители. Ответ чтения всегда вычисляется заново по текущему значению
+ * source, поэтому лишнее пробуждение безвредно, а пропущенных не бывает:
+ * каждая запись, меняющая ответ ключа, сдвигает его счётчик. Вне группировки
+ * сдвиг сразу делает потребителя обязательным к пересчёту, внутри неё остаётся
+ * у trigger, пока его не прочитает потребитель. Сдвиги не отменяют друг друга:
+ * потребитель ключа, через который batch прошёл туда и обратно, выполняется
+ * один лишний раз. Исключение то же, что у обычного signal: потребитель,
+ * который сам выполнялся в момент записи вне группировки и которого engine не
+ * планирует заново, и читатели такого потребителя (см. `_bump`).
+ *
+ * Trigger нужен, пока у него есть потребители. Как selector узнаёт, что их не
+ * осталось, зависит от ключа.
+ *
+ * - Ключ-объект или функция. Его trigger снимается вместе с последней связью
+ *   графа: selector не удерживает объект дольше его потребителей. Цена —
+ *   cleanup на каждую связь.
+ * - Остальные ключи. Связи с их triggers ничем не отличаются от связей с
+ *   signal, и потребитель не платит за selector ни при создании связи, ни при
+ *   её снятии. Trigger без потребителей остаётся в индексе до уборки. Уборка
+ *   идёт при записи в source, которая затрагивает такой ключ; когда индекс
+ *   вырос вдвое после прошлой уборки; когда Runtime после прошлой уборки
+ *   освободил не меньше владельцев, чем ключей в индексе; при освобождении
+ *   владельца selector. Уборка после освобождений, которая ничего не убрала,
+ *   удваивает срок следующей: освобождения посторонних владельцев стоят
+ *   selector логарифма от их числа, а не уборки на каждые несколько из них.
+ *   Удержанный до уборки trigger — одна запись графа и значение ключа;
+ *   потребителей он не удерживает.
+ *
+ * Индекс triggers состоит из двух частей. Целые ключи, идущие подряд по
+ * возрастанию — ключи строк списка, — лежат в ряду: место ряда принадлежит
+ * ключу «начало ряда плюс номер места», и ключ стоит selector одного места
+ * массива, без записи `Map` и без хеширования. Все остальные ключи лежат в
+ * общем индексе `Map`, который создаётся с первым таким ключом. У ключа ровно
+ * один trigger: ключ, попавший в общий индекс, остаётся в нём, и ряд через
+ * него не растёт. Место ряда принадлежит ключу, только если сумма начала ряда
+ * и номера места равна самому ключу: нецелый ключ места не получает никогда.
+ *
+ * Запись со своим сравнением обходит сначала ряд по возрастанию ключей, затем
+ * общий индекс в порядке первого чтения ключей. В этом порядке она будит
+ * потребителей; порядок может измениться и контрактом не является.
+ *
+ * Поля объявлены через `declare` и присваиваются в constructor в одном
+ * порядке: у всех selectors один hidden class.
+ *
+ * @internal
+ */
+export declare class RuntimeSelector<Key> implements OwnedSourceEntry, RuntimeSignalWriteTap, RuntimeDisposalSweeper {
+    /**
+     * Публичное чтение selector; одна функция на весь его lifetime.
+     */
+    readonly select: RaphSelector<Key>;
+    /**
+     * Источник, зарегистрированный у владельца перед этим.
+     * @internal
+     */
+    _previousSource: OwnedSourceEntry | undefined;
+    /**
+     * Ключ-объект текущего отслеживаемого чтения: по нему hook onDependency
+     * узнаёт, для какого ключа engine создаёт связь. Вне чтения поле пусто.
+     * @internal
+     */
+    _trackedKey: Key | undefined;
+    private readonly _owner;
+    private readonly _reactivity;
+    private readonly _source;
+    private _equals;
+    private readonly _dense;
+    private _denseBase;
+    private _denseCount;
+    private _triggers;
+    private _scanning;
+    private readonly _objectHooks;
+    private _growthLimit;
+    private _sweptAt;
+    private _sweepStride;
+    private _disposed;
+    /**
+     * Место selector среди наблюдателей записи source; ведёт source.
+     * @internal
+     */
+    _tapSlot: number;
+    /**
+     * Место selector в очереди уборки Runtime; -1, пока selector в ней не стоит.
+     * Ведёт Runtime.
+     * @internal
+     */
+    _sweepSlot: number;
+    /**
+     * Срок selector в очереди уборки Runtime; ведёт Runtime.
+     * @internal
+     */
+    _sweepDue: number;
+    /**
+     * Создаёт selector и подключает его к записям source. Регистрацию у
+     * владельца и проверку аргументов выполняет вызывающий код.
+     */
+    constructor(owner: RaphScope, reactivity: RuntimeReactivity, source: RuntimeSignal<Key>, equals: ((key: Key, value: Key) => boolean) | undefined);
+    /**
+     * Тег Object.prototype.toString: инструменты, которые обходят только plain
+     * objects, принимают selector за неделимое значение и не идут через него в
+     * граф Runtime.
+     */
+    get [Symbol.toStringTag](): string;
+    /**
+     * Возвращает компактное описание вместо собственных полей: они ведут к
+     * владельцу, Runtime и графу зависимостей.
+     */
+    toJSON(): RuntimeSelectorDescription;
+    /**
+     * Владелец selector как наблюдателя записей source.
+     * @internal
+     */
+    get _tapOwner(): RaphScope;
+    /**
+     * Число ключей в индексе triggers: с потребителями и ещё не убранных.
+     * @internal
+     */
+    _debugTriggerCount(): number;
+    /**
+     * Отвечает, совпадает ли ключ с текущим значением source, и подписывает
+     * активного потребителя на trigger этого ключа. Чтение проверяется как
+     * чтение signal владельца selector: тот же lifetime, тот же запрет чужого
+     * Runtime и то же правило implicit-зависимостей.
+     *
+     * Подписка идёт раньше сравнения: потребитель, у которого чтение source или
+     * сравнение бросило исключение, всё равно будет разбужен следующей записью.
+     * @internal
+     */
+    _test(key: Key): boolean;
+    /**
+     * Сообщает, что запись в source может разбудить потребителей selector.
+     * @internal
+     */
+    _observesWrites(): boolean;
+    /**
+     * Будит потребителей ключей, чей ответ изменила запись в source. Вызывается
+     * signal-ом после того, как новое значение стало видимым, внутри его границы
+     * записи. Сбой одного пробуждения не отменяет остальные.
+     * @internal
+     */
+    _afterSourceWrite(previous: unknown, value: unknown): void;
+    /**
+     * Убирает triggers без потребителей, когда Runtime после прошлой уборки
+     * освободил не меньше владельцев, чем ключей в индексе: при массовом
+     * освобождении потребителей индекс пустеет одной уборкой на последнем из
+     * них. Вызов до срока стоит одного сравнения.
+     *
+     * Уборка, которая ничего не убрала, удваивает срок следующей: владельцы,
+     * освобождённые за это время, не держали потребителей selector, и чем дольше
+     * так продолжается, тем реже selector проверяет индекс. Первая же уборка,
+     * которая что-то убрала, возвращает прежний срок. Опустевший selector
+     * выходит из уборки Runtime и вернётся в неё с первым новым trigger.
+     * @internal
+     */
+    _afterOwnerDisposals(disposals: number): number;
+    /**
+     * Обрабатывает снятие одной связи графа с trigger ключа-объекта. Engine
+     * вызывает cleanup связи до того, как вынет её из списка потребителей:
+     * связь, оставшаяся в списке единственной, и есть снимаемая, и вместе с ней
+     * ключ теряет последнего потребителя. Запись графа при этом не
+     * освобождается: её список потребителей в этот момент обходит engine, а без
+     * потребителей и без ссылки из индекса она недостижима.
+     * @internal
+     */
+    _edgeDetached(key: Key): void;
+    /**
+     * Ищет среди потребителей всех triggers первого, чьего владельца принимает
+     * accept, и возвращает этого владельца: implicit-рёбра selector лежат только
+     * в графе, как и рёбра Runtime signal.
+     * @internal
+     */
+    _findConsumerOwner<Context>(accept: (consumerOwner: object, context: Context) => boolean, context: Context): object | undefined;
+    /**
+     * Освобождает selector как источник владельца: отключает его от записей
+     * source и от уборки Runtime и отсоединяет оставшихся потребителей от всех
+     * triggers. Сбой одного шага не отменяет остальные. Повторный вызов
+     * безопасен.
+     * @internal
+     */
+    _finalizeSource(): boolean;
+    /**
+     * Убирает из индекса triggers без потребителей и запоминает, сколько
+     * владельцев Runtime освободил к этому моменту. Индекс, в котором
+     * потребителей не осталось ни у кого, очищается целиком.
+     * @internal
+     */
+    _sweep(disposals?: number): void;
+    /**
+     * Число ключей в обеих частях индекса: с потребителями и ещё не убранных.
+     */
+    private _size;
+    /**
+     * Подписывает активного потребителя на trigger ключа; без потребителя ничего
+     * не создаёт. Trigger появляется первым отслеживаемым чтением ключа.
+     */
+    private _track;
+    /**
+     * Создаёт trigger целого ключа на месте `offset` ряда: в конце ряда либо на
+     * месте, чей прежний trigger убран. Без активного потребителя ничего не
+     * создаёт, и пустой ряд остаётся пустым.
+     */
+    private _trackDense;
+    /**
+     * Подписывает активного потребителя на trigger ключа-объекта: связь с ним
+     * получает cleanup, который помнит ключ.
+     */
+    private _trackObject;
+    /**
+     * Убирает triggers без потребителей, когда индекс вырос вдвое после прошлой
+     * уборки, и назначает следующий порог роста: цена уборок остаётся
+     * постоянной на один новый trigger. С первым trigger подключает selector к
+     * уборке Runtime после освобождения владельцев.
+     */
+    private _grow;
+    /**
+     * Будит потребителей прежнего и нового значения source при сравнении
+     * SameValueZero: ответ изменился только у этих двух ключей. Trigger нового
+     * значения ищется после пробуждения прежнего, которое могло изменить индекс.
+     */
+    private _wakePair;
+    /**
+     * Сдвигает счётчик trigger: его потребители получают invalidation. Trigger
+     * без потребителей убирается из индекса здесь.
+     *
+     * Значение trigger только растёт, поэтому сдвиг нельзя отменить следующим:
+     * ключ, через который batch прошёл туда и обратно, остаётся изменённым, пока
+     * его не прочитает потребитель.
+     *
+     * Сдвиг — обычная запись signal. Вне группировки она прямая, и потребителя
+     * engine делает обязательным к пересчёту в любом его состоянии: без пометок,
+     * помеченного «проверить» записью, которую её batch затем отменил
+     * (`direct-write-after-check.spec.ts`), и стоящего на стеке собственной
+     * проверки зависимостей, getter которой записал source
+     * (`direct-write-during-check.spec.ts`, блок `selector trigger`). Внутри
+     * группировки сдвиг откладывается у trigger до первого чтения вместе с
+     * записью самого source.
+     *
+     * Потребителя, который выполняется в момент прямого сдвига, engine помечает
+     * как при записи любого signal, и непрочитанного сдвига у trigger для него
+     * не остаётся. Runtime планирует заново только phase effect, который читает
+     * selector сам. Effect без задачи и computed, вернувший прежнее значение,
+     * остаются со старым ответом до следующей записи, которая меняет ответ
+     * ключа: пометку записи, пришедшей во время запуска, engine с них снимает.
+     * Старый ответ такого computed получает и каждый его читатель — phase effect
+     * любой формы регистрации, watch и прямое чтение, — в том числе после
+     * собственного повторного запуска. Отложенный сдвиг подтверждала им
+     * следующая проверка зависимостей или следующий читатель ключа, прямой —
+     * нет; обычный signal на месте selector ведёт себя так же, как прямой сдвиг
+     * (тот же файл, блок `selector source written while a consumer of the key
+     * runs`; причина в engine — блок `known limitations`).
+     */
+    private _bump;
+    /**
+     * Сравнивает один наблюдаемый ключ с прежним и с новым значением source и
+     * будит его потребителей, если ответ изменился. Ответ, который не удалось
+     * вычислить, считается изменившимся: потребитель встретит то же исключение
+     * в собственном чтении. Сбои копятся в `errors`; возвращается их список.
+     */
+    private _wakeChanged;
+    /**
+     * Возвращает trigger ключа из той части индекса, где лежит ключ. Место ряда
+     * с убранным trigger отвечает undefined, как отсутствующий ключ. Место ряда
+     * проверяется так же, как при чтении: по нему должен получаться сам ключ.
+     */
+    private _find;
+    /**
+     * Убирает trigger ключа из той части индекса, где лежит ключ.
+     *
+     * Место ряда остаётся пустым, и ряд не сдвигается, даже когда ключ стоял на
+     * его краю: запись, убравшая ключ, стоит одинаково при любой длине ряда.
+     * Порядок в ряду наводит уборка, которая и так обходит его целиком. Запись
+     * делает это сама в двух случаях: ряд опустел, либо мест в нём стало больше,
+     * чем вдвое против допустимого для обрезанного ряда. Во втором случае проход
+     * оставляет от ряда меньше половины мест либо переносит его в общий индекс,
+     * поэтому его цена ложится на создание убранных мест, а не на записи.
+     */
+    private _forget;
+    /**
+     * Приводит ряд в порядок после того, как из него убраны triggers: опустевший
+     * ряд становится пустым, пустые места с краёв срезаются, а ряд, в котором
+     * после этого мест больше удвоенного числа занятых плюс запас, целиком
+     * переносится в общий индекс. Так ряд занимает память, пропорциональную
+     * числу своих ключей, какой бы старый ключ ни остался наблюдаемым.
+     *
+     * Проход стоит длины ряда, поэтому его вызывают уборка и запись со своим
+     * сравнением, которые обходят ряд сами, а запись, убравшая один ключ, —
+     * только по правилу из `_forget()`. Пока запись обходит индекс, ряд не
+     * сдвигается и не переносится: порядок наведёт сам обход.
+     *
+     * Срез начала сдвигает начало ряда на число срезанных мест. Ключ первого
+     * оставшегося места — целое число, равное этой сумме, поэтому сложение
+     * точное.
+     */
+    private _settleDense;
+}

package/dist/runtime/reactivity/RaphWorkGraph.d.ts

@@ -4,7 +4,7 @@ import { RaphScope } from '../ownership/RaphScope';
 import { RaphAggregateSource, RaphStructureCause, RaphWatchInclude, RaphWatchSource, RaphWorkCause, RaphWorkCauseKind } from '../phases/phase.types';
 import { RaphRuntime } from '../RaphRuntime';
 type WorkSink = (cause: RaphWorkCause, key: object, schedule: boolean) => void;
-type WorkEdgeSource = RaphProducerRecord | RaphNode | RaphRuntime;
+type WorkEdgeSource = RaphProducer | RaphNode | RaphRuntime;
 interface WorkEdge {
     readonly sink: WorkSink;
     readonly kind: 'producer' | 'runtime' | 'self' | 'subtree';
@@ -17,7 +17,7 @@ interface WorkEdgeList {
     first?: WorkEdge;
     last?: WorkEdge;
 }
-type CleanupSource = RaphProducerRecord | RaphNode | RaphAggregate;
+type CleanupSource = RaphProducer | RaphNode | RaphAggregate;
 interface CleanupEdge {
     cleanup?: () => void;
     source?: CleanupSource;
@@ -37,25 +37,70 @@ interface AggregateSubscription {
 interface ProducerOptions {
     readonly includeRuntime?: boolean;
 }
-declare const PRODUCER_RECORD: unique symbol;
 /** @internal */
-export interface RaphProducerRecord {
-    readonly [PRODUCER_RECORD]: true;
-    readonly runtime: RaphRuntime;
+export type RaphProducerKind = Extract<RaphWorkCauseKind, 'frame' | 'path' | 'producer'>;
+/**
+ * Компактное описание producer, которое возвращает его toJSON(): только
+ * примитивы, без ссылок на владельца, Runtime и граф зависимостей.
+ *
+ * @internal
+ */
+export interface RaphProducerDescription {
+    readonly kind: RaphProducerKind;
+    readonly owner: string;
+    readonly revision: number;
+    readonly disposed: boolean;
+}
+/**
+ * Runtime-сторона одного granular source: адрес explicit watch, token причины
+ * для implicit consumers и носитель последней причины. Runtime signal
+ * наследует этот класс и сам является своим producer; остальные handles
+ * получают отдельную запись через createProducer() и реестр.
+ *
+ * Поля объявлены через `declare` и присваиваются в constructor в одном
+ * порядке: у всех producers один hidden class, и ни один build target не
+ * превращает объявления в вызовы field-helper.
+ *
+ * @internal
+ */
+export declare class RaphProducer {
     readonly owner: RaphScope;
-    readonly kind: Extract<RaphWorkCauseKind, 'frame' | 'path' | 'producer'>;
+    readonly kind: RaphProducerKind;
     readonly includeRuntime: boolean;
-    subscribers?: WorkEdgeList;
-    memberships?: CleanupEdgeList;
-    implicitConsumers?: Map<RaphNode, number>;
-    alias?: object;
-    source?: RaphWatchSource;
-    activate?: () => void | Disposer;
-    runtimeActivation?: Disposer;
-    lastCause?: RaphWorkCause;
-    transientNext?: RaphProducerRecord;
+    subscribers: WorkEdgeList | undefined;
+    memberships: CleanupEdgeList | undefined;
+    implicitConsumers: Map<RaphNode, number> | undefined;
+    source: RaphWatchSource | undefined;
+    activate: (() => void | Disposer) | undefined;
+    runtimeActivation: Disposer | undefined;
+    lastCause: RaphWorkCause | undefined;
+    transientNext: RaphProducer | undefined;
     revision: number;
     disposed: boolean;
+    /**
+     * Prototype-бренд producer: `true` у RaphProducer и его наследников. Заменяет
+     * `instanceof` там, где причина ищется по token на каждое уведомление
+     * implicit consumer. Значение лежит на prototype и не занимает поле экземпляра.
+     * @internal
+     */
+    readonly _isProducer: boolean;
+    constructor(owner: RaphScope, kind: RaphProducerKind, includeRuntime: boolean);
+    get runtime(): RaphRuntime;
+    /**
+     * Тег Object.prototype.toString: `[object RaphProducer]`. По нему инструменты,
+     * которые копируют и обходят только plain objects, принимают producer за
+     * неделимое значение: тестовый runner не клонирует его вместе со всем графом
+     * Runtime перед печатью diff. Accessor лежит на prototype.
+     */
+    get [Symbol.toStringTag](): string;
+    /**
+     * Возвращает компактное описание вместо собственных полей. Поля producer
+     * ведут к владельцу, Runtime и графу зависимостей: без этого метода
+     * JSON.stringify упирался бы в циклы, а печать значения в логах и в diff
+     * неуспешной проверки тестового runner-а обходила бы весь граф Runtime.
+     * Метод лежит на prototype и не добавляет producer ни поля, ни closure.
+     */
+    toJSON(): RaphProducerDescription;
 }
 /** Immutable explicit group of granular sources owned by one Runtime scope. */
 export declare class RaphAggregate {
@@ -102,6 +147,12 @@ export declare class RaphAggregate {
 /** Runtime-only intrusive indexes for granular sources. */
 export declare class RaphWorkGraph {
     private readonly _runtime;
+    /**
+     * Удерживает форму причины записи значения, пока в isolate нет ни одной
+     * живой причины.
+     * @internal
+     */
+    static _valueCauseShapeAnchor: RaphWorkCause;
     private _selfSubscribers;
     private _subtreeSubscribers;
     private _runtimeSubscribers;
@@ -116,15 +167,53 @@ export declare class RaphWorkGraph {
     private _detachedEdges;
     private _disposed;
     constructor(_runtime: RaphRuntime);
-    createProducer(owner: RaphScope, kind?: RaphProducerRecord['kind'], options?: ProducerOptions): RaphProducerRecord;
-    attachProducer<T extends object>(record: RaphProducerRecord, source: T): T;
-    setProducerActivation(record: RaphProducerRecord, activate: () => void | Disposer, activateForRuntime?: boolean): void;
-    producerHooks(record: RaphProducerRecord): OwnedSourceHooks;
+    createProducer(owner: RaphScope, kind?: RaphProducerKind, options?: ProducerOptions): RaphProducer;
+    attachProducer<T extends object>(record: RaphProducer, source: T): T;
+    setProducerActivation(record: RaphProducer, activate: () => void | Disposer, activateForRuntime?: boolean): void;
+    producerHooks(record: RaphProducer): OwnedSourceHooks;
+    /**
+     * Возвращает последнюю причину producer, который engine назвал своим token.
+     * Token чужого Runtime и значение, не являющееся producer, причины не имеют.
+     *
+     * Метод вызывается на каждое уведомление implicit consumer, поэтому producer
+     * распознаётся prototype-брендом, а Runtime читается у владельца напрямую:
+     * без `instanceof` и без accessor.
+     */
     causeForToken(token: unknown): RaphWorkCause | undefined;
     /** Clears mutation-local payloads after engine propagation consumed them. */
     clearTransientCauses(): void;
-    notifyProducer(record: RaphProducerRecord, previous?: unknown, value?: unknown, events?: RaphWorkCause['events'], schedule?: boolean, hasReactiveSubscribers?: boolean, includeValues?: boolean): void;
-    notifyProducerEvents(record: RaphProducerRecord, events: NonNullable<RaphWorkCause['events']>, schedule?: boolean, hasReactiveSubscribers?: boolean): void;
+    notifyProducer(record: RaphProducer, previous?: unknown, value?: unknown, events?: RaphWorkCause['events'], schedule?: boolean, hasReactiveSubscribers?: boolean, includeValues?: boolean): void;
+    /**
+     * Публикует запись значения producer: форма `notifyProducer()` для причины с
+     * `previous` и `value`, без events и с планированием. Так свою запись
+     * публикует Runtime signal.
+     *
+     * Причина создаётся при тех же условиях и с теми же полями. Отличие в цене:
+     * у producer с implicit consumers, на который не подписан ни один watch, ни
+     * его node, ни поддерево, ни Runtime, причину получают только consumers через
+     * `causeForToken()`. Тогда обход подписчиков не начинается: запись не строит
+     * массив предков и не выполняет ни одного вызова на каждого из них.
+     *
+     * @internal
+     */
+    _notifyValueWrite(record: RaphProducer, previous: unknown, value: unknown, hasReactiveSubscribers: boolean): void;
+    notifyProducerEvents(record: RaphProducer, events: NonNullable<RaphWorkCause['events']>, schedule?: boolean, hasReactiveSubscribers?: boolean): void;
+    /**
+     * Дешёвая предварительная проверка structural publication: `false` означает,
+     * что `notifyNode` для этой node вернётся до создания cause и без побочных
+     * эффектов. `true` консервативен и ведёт на полный путь.
+     *
+     * @internal
+     */
+    _hasStructuralDemand(node: RaphNode): boolean;
+    /**
+     * Сообщает, есть ли хотя бы один runtime-, subtree- или self-подписчик.
+     * `true` означает, что `_hasStructuralDemand` может вернуть `true` для
+     * какой-то node этого Runtime.
+     *
+     * @internal
+     */
+    _hasNodeSubscribers(): boolean;
     notifyNode(node: RaphNode, kind: Extract<RaphWorkCauseKind, 'structure' | 'touch'>, options?: {
         readonly metadata?: unknown;
         readonly structure?: RaphStructureCause;
@@ -134,18 +223,67 @@ export declare class RaphWorkGraph {
     createAggregate(owner: RaphScope, sources: readonly RaphAggregateSource[]): RaphAggregate;
     subscribe(input: RaphWatchSource, include: RaphWatchInclude | undefined, sink: WorkSink): () => void;
     assertSubscriptionAllowed(consumer: RaphScope, input: RaphWatchSource): void;
-    /** Rejects a move that would make an existing implicit reactive edge illegal. */
+    /**
+     * Rejects a move that would make an existing implicit reactive edge illegal.
+     *
+     * Рёбра от producers с отдельной записью (computed, machine) берутся из
+     * учёта `implicitConsumers`. Рёбра от Runtime signals нигде не учитываются:
+     * они читаются из графа в момент проверки.
+     */
     assertReparentAllowed(node: RaphNode, newParent: RaphNode): void;
+    /**
+     * Проверяет живые implicit-рёбра от Runtime signals. Implicit-чтение
+     * разрешено только у собственного владельца, его предков и root scope,
+     * поэтому внешний для переносимого поддерева источник всегда принадлежит
+     * прежнему предку `node`. Предок, который остаётся предком нового parent,
+     * сохраняет все свои рёбра законными. Остаются предки от прежнего parent до
+     * ближайшего общего с новым parent, не включая его: перенос запрещён, если
+     * signal такого предка читает потребитель из переносимого поддерева.
+     *
+     * Посылка о прежнем предке держится на проверке самого чтения: Runtime
+     * signal отклоняет implicit-чтение чужого владельца и тогда, когда общий
+     * контекст владельца снят untracked-работой другого Runtime, а потребитель
+     * этого Runtime остался активным (assertReadable в RuntimeReactivity).
+     *
+     * Цена переноса. Перенос под прежнего parent и перенос корня дерева
+     * проверки не требуют. Иначе для каждого покидаемого предка обходится весь
+     * список его источников (не-signals пропускаются за один шаг), а у каждого
+     * signal с записью графа — список его потребителей до первого потребителя
+     * из переносимого поддерева. Итого O(покидаемые предки × их источники +
+     * потребители их signals), без аллокаций. Цена не зависит от того, сколько
+     * рёбер между nodes есть в остальном Runtime, но растёт с числом источников
+     * и потребителей у покидаемых предков, даже когда их signals читает только
+     * сам владелец: перенос из-под parent с тысячей signals обходит всю тысячу.
+     * Прежний учёт рёбер стоил наоборот: ничего для таких signals и обход всех
+     * producers Runtime с рёбрами между nodes вместе с их потребителями, где бы
+     * в дереве они ни находились.
+     */
+    private _assertSignalEdgesAllowReparent;
     releaseNode(node: RaphNode): void;
     dispose(): void;
-    private _disposeProducer;
+    /**
+     * Освобождает producer: публикует финальную structural cause при спросе и
+     * снимает его подписчиков, memberships и регистрацию. Вызывается hook-ом
+     * onDispose owned-источника и самим Runtime signal.
+     *
+     * @internal
+     */
+    _disposeProducer(record: RaphProducer, hasReactiveSubscribers?: boolean): void;
     private _dispatchProducer;
     private _dispatchProducerLazily;
     private _createProducerCause;
     private _retainRuntimeSubscriber;
     private _releaseRuntimeSubscriber;
     private _releaseRuntimeActivations;
-    private _linkImplicitDependency;
+    /**
+     * Учитывает одно фактическое implicit-ребро графа от producer к consumer
+     * owner и возвращает его точное снятие. Вызывается hook-ом onDependency
+     * producers с отдельной записью; Runtime signal этого hook не имеет, и его
+     * рёбра проверка reparent читает прямо из графа.
+     *
+     * @internal
+     */
+    _linkImplicitDependency(record: RaphProducer, consumerOwner: object): (() => void) | undefined;
     private _subscribeOne;
     private _subscribeNode;
     private _createNodeEdgeRelease;