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

package/dist/runtime/phases/RaphPhaseWatch.d.ts

@@ -0,0 +1,22 @@
+import { Disposer } from '../../reactivity/types';
+import { RaphPhaseTaskRecord } from './RaphPhaseTaskRecord';
+import { RuntimeWatch } from '../reactivity/RuntimeWatch';
+/**
+ * Callback lifecycle одного explicit watch binding вместе с подпиской, которая
+ * его питает. Подписка освобождается при освобождении binding, до cleanup
+ * последней доставки.
+ *
+ * Lifecycle достаёт callback только через запись своего binding и сбрасывает
+ * эту ссылку при освобождении. Публичный watch disposer удерживает lifecycle,
+ * а не запись, поэтому disposer, переживший свой binding, не удерживает ни
+ * callback, ни захваченное им.
+ */
+export declare class RaphPhaseWatch extends RuntimeWatch {
+    source: Disposer | undefined;
+    record: RaphPhaseTaskRecord | undefined;
+    /**
+     * Создаёт lifecycle без подписки и без binding; оба поля задаёт регистрация.
+     */
+    constructor(runUntracked: <T>(operation: () => T) => T, callback: () => void | Disposer);
+}
+export declare function createPhaseWatch(runUntracked: <T>(operation: () => T) => T, record: RaphPhaseTaskRecord): RaphPhaseWatch;

package/dist/runtime/phases/orderPhaseTasks.d.ts

@@ -0,0 +1,6 @@
+import { RaphPhaseTask, RaphTaskOrderOptions } from './phase.types';
+/**
+ * Возвращает новый массив задач в tree-order выбранной пользователем owner-плоскости.
+ * Исходный batch и persistent task identities не изменяются.
+ */
+export declare function orderPhaseTasks(tasks: readonly RaphPhaseTask[], options: RaphTaskOrderOptions): RaphPhaseTask[];

package/dist/runtime/phases/phase.types.d.ts

@@ -0,0 +1,171 @@
+import { RaphMetaMutationEvent } from '../../path/meta/meta.types';
+import { PathEvent } from '../../path/path.types';
+import { Disposer, ReadonlySignal } from '../../reactivity/types';
+import { RaphNode } from '../ownership/RaphNode';
+import { RaphScope } from '../ownership/RaphScope';
+import { RaphRuntime } from '../RaphRuntime';
+import { RaphMetaSource } from '../reactivity/RaphMetaSource';
+import { RaphAggregate } from '../reactivity/RaphWorkGraph';
+export declare const RaphSchedulerType: Readonly<{
+    readonly AnimationFrame: "animationFrame";
+    readonly Microtask: "microtask";
+    readonly Sync: "sync";
+}>;
+export type RaphSchedulerMode = typeof RaphSchedulerType[keyof typeof RaphSchedulerType];
+export type RaphEffectInitialMode = 'scheduled' | 'sync';
+export type RaphWatchInitialMode = RaphEffectInitialMode | 'none';
+export interface FrameLoopLease {
+    readonly owner: string;
+    release: () => void;
+}
+export interface RaphFrameContext {
+    readonly now: number;
+    readonly delta: number;
+    readonly elapsed: number;
+    readonly frame: number;
+}
+export interface RaphStructureCause {
+    readonly node: RaphNode;
+    readonly oldParent?: RaphNode;
+    readonly newParent?: RaphNode;
+    readonly oldIndex?: number;
+    readonly newIndex?: number;
+}
+export type RaphWorkCauseKind = 'producer' | 'structure' | 'path' | 'frame' | 'touch';
+/** Одна logical причина phase delivery. Повторные причины одного source coalesce. */
+export interface RaphWorkCause {
+    readonly kind: RaphWorkCauseKind;
+    readonly source: RaphWatchSource;
+    readonly sourceOwner?: RaphScope;
+    readonly revision: number;
+    readonly previous?: unknown;
+    readonly value?: unknown;
+    readonly structure?: RaphStructureCause;
+    readonly events?: readonly (PathEvent | RaphMetaMutationEvent)[];
+    readonly metadata?: unknown;
+}
+export type RaphPhaseEffect = (task: RaphPhaseTask) => void | Disposer;
+/**
+ * Тело binding, зарегистрированного через `bindEffect`: task ему не передаётся,
+ * поэтому тело объявляется без параметров. Возвращённый cleanup выполняется
+ * перед следующим запуском и при освобождении binding.
+ */
+export type RaphPhaseBody = () => void | Disposer;
+/**
+ * Запуск одного slot группы: кортеж, который получает тело slot. Первый элемент
+ * — context группы, второй — номер исполняемого slot, считая с нуля.
+ *
+ * Кортеж один на группу и принадлежит ей: номер slot в нём меняется от запуска
+ * к запуску, а остальные элементы — внутреннее состояние группы. Тело читает
+ * первые два элемента по индексу во время вызова и не сохраняет кортеж.
+ *
+ * Кортеж — живое состояние группы, а не копия: от записи его защищает только
+ * тип. Тело, которое пишет в кортеж или читает элементы после второго,
+ * нарушает contract: запись в первый элемент подменяет context следующим
+ * slots, запись в остальные ломает доставку группы.
+ *
+ * @typeParam Context — значение, которое группа передаёт телу каждого slot.
+ */
+export type RaphEffectGroupRun<Context = unknown> = readonly [
+    context: Context,
+    slot: number,
+    ...state: readonly unknown[]
+];
+/**
+ * Тело одного slot группы, зарегистрированной через `effectGroup`. Получает
+ * один аргумент — запуск с context группы и номером slot; task ему не
+ * передаётся. Чтения внутри вызова отслеживаются отдельно для каждого slot, а
+ * возвращённый cleanup принадлежит этому slot: он выполняется перед его
+ * следующим запуском и при освобождении группы.
+ *
+ * Аргумент один, как у тела `effect()`: общее для всех effects тело записи
+ * engine вызывает тело slot напрямую, без промежуточной функции на каждый
+ * запуск slot.
+ *
+ * @typeParam Context — значение, которое группа передаёт телу каждого slot.
+ */
+export type RaphEffectGroupSlot<Context = unknown> = (run: RaphEffectGroupRun<Context>) => void | Disposer;
+/** Настройки группы effects: порядок её task среди bindings той же phase. */
+export interface RaphEffectGroupOptions {
+    readonly priority?: number;
+}
+/**
+ * Группа effects одного binding, которую вернул `effectGroup`. Slots группы
+ * ничего не исполняют, пока их не запустит `start`; метод вызывается через
+ * группу или с явным receiver.
+ *
+ * Возвращаемое значение — сама запись binding, а не отдельный объект: handle
+ * не стоит группе аллокации. Contract — только `start`; остальные поля и
+ * методы записи внутренние, и обращение к ним нарушает contract.
+ */
+export interface RaphEffectGroup {
+    /**
+     * Запускает slot: с этого вызова slot ведёт себя как binding, который
+     * `bindEffect()` зарегистрировал бы в этом месте. `initial` задаёт первую
+     * доставку так же, как у `effect()`: `'scheduled'` (по умолчанию) ставит её
+     * в очередь, `'sync'` исполняет её до возврата из вызова, если Runtime не
+     * занят доставкой и группа не на pause.
+     *
+     * Если первая доставка выполняется внутри вызова и flush бросает ошибку,
+     * slot останавливается окончательно, а ошибка бросается вызывающему, как
+     * при сбое регистрации отдельного binding. Остальные slots группы остаются.
+     * Запуск остановленного slot и повторный запуск уже запущенного slot не
+     * исполняют его тело.
+     *
+     * Запуск на освобождённом владельце бросает `RaphDisposedError`, как
+     * `bindEffect()`: и когда владелец освобождён до вызова, и когда его
+     * освободила первая доставка внутри этого вызова, при любом scheduler.
+     * Запуск slot группы, которую освободили при живом владельце — через её
+     * effect scope либо остановкой последнего slot, — ничего не делает.
+     */
+    start: (this: RaphEffectGroup, slot: number, initial?: RaphEffectInitialMode) => void;
+}
+/**
+ * Persistent task identity, передаваемая phase process и effect callback.
+ * run/defer/cancel вызываются через task или с явным receiver: извлечённый
+ * метод не работает без this.
+ */
+export interface RaphPhaseTask {
+    readonly phase: string;
+    readonly consumerOwner: RaphScope;
+    readonly effect: RaphPhaseEffect;
+    readonly causes: readonly RaphWorkCause[];
+    readonly frame: RaphFrameContext;
+    readonly priority: number;
+    readonly sequence: number;
+    run: (this: RaphPhaseTask) => void;
+    defer: (this: RaphPhaseTask) => void;
+    cancel: (this: RaphPhaseTask) => void;
+}
+export interface RaphPhaseBatch {
+    readonly phase: string;
+    readonly frame: RaphFrameContext;
+    readonly tasks: readonly RaphPhaseTask[];
+}
+export interface RaphPhase {
+    readonly name: string;
+    readonly process?: (batch: RaphPhaseBatch) => void;
+}
+export interface RaphEffectOptions {
+    readonly initial?: RaphEffectInitialMode;
+    readonly priority?: number;
+}
+export type RaphWatchInclude = 'self' | 'subtree';
+export interface RaphWatchOptions extends Omit<RaphEffectOptions, 'initial'> {
+    /** `none` creates a change-only binding without an initial delivery. */
+    readonly initial?: RaphWatchInitialMode;
+    /** Применяется только к RaphNode source; default — self. */
+    readonly include?: RaphWatchInclude;
+}
+export interface RaphNodeWatchSource {
+    readonly source: RaphNode;
+    readonly include: RaphWatchInclude;
+}
+export type RaphProducerSource = ReadonlySignal<unknown>;
+export type RaphWatchSource = RaphProducerSource | RaphNode | RaphNodeWatchSource | RaphRuntime | RaphAggregate | RaphMetaSource;
+export type RaphOwnerWatchSource = RaphWatchSource;
+export type RaphAggregateSource = RaphOwnerWatchSource;
+export interface RaphTaskOrderOptions {
+    readonly node: (task: RaphPhaseTask) => RaphNode | null | undefined;
+    readonly direction?: 'parents-first' | 'children-first';
+}

package/dist/runtime/{PathHandle.d.ts → reactivity/PathHandle.d.ts}

@@ -1,8 +1,8 @@
-import { ParsedDataPath } from '../path/data-path';
-import { PathOptions } from '../path/path.types';
-import { RaphKernel } from '../path/RaphKernel';
-import { RaphReactivity } from '../reactivity/engine';
-import { ReadonlySignal } from '../reactivity/types';
+import { ParsedDataPath } from '../../path/data-path.types';
+import { PathEvents, PathOptions } from '../../path/path.types';
+import { RaphKernel } from '../../path/RaphKernel';
+import { RaphReactivity } from '../../reactivity/engine';
+import { Disposer, OwnedSourceHooks, ReadonlySignal } from '../../reactivity/types';
 type PathSignalEngine = Pick<RaphReactivity, '_isTracking' | '_ownedSignal'>;
 /**
  * Реактивный handle одного canonical path в default E2 data-plane.
@@ -20,13 +20,17 @@ export declare class PathHandle<T> implements ReadonlySignal<T | undefined> {
     private _assertTrackedRead;
     private _assertWriteAllowed;
     private _runWrite;
+    private _notifyEvents;
+    private _hasRevisionSubscribers;
     private _stop;
+    private _activationLeases;
+    private _trackedActivation;
     private _disposed;
     /**
      * Создаёт internal path handle и связывает его с runtime lifecycle.
      * @internal
      */
-    constructor(store: RaphKernel, parsed: ParsedDataPath, options: PathOptions, release: (handle: PathHandle<unknown>) => void, signals: PathSignalEngine, assertOwnerAlive?: () => void, assertTrackedRead?: () => void, assertWriteAllowed?: () => void, runWrite?: <Result>(operation: () => Result) => Result);
+    constructor(store: RaphKernel, parsed: ParsedDataPath, options: PathOptions, release: (handle: PathHandle<unknown>) => void, signals: PathSignalEngine, assertOwnerAlive?: () => void, assertTrackedRead?: () => void, assertWriteAllowed?: () => void, runWrite?: <Result>(operation: () => Result) => Result, sourceHooks?: OwnedSourceHooks, notifyEvents?: (events: PathEvents, hasReactiveSubscribers: boolean) => void);
     /**
      * Показывает, освобождён ли path handle.
      */
@@ -59,13 +63,17 @@ export declare class PathHandle<T> implements ReadonlySignal<T | undefined> {
      * Отсоединяет Kernel subscription и освобождает reactive revision handle.
      */
     dispose(): void;
+    private _disposeNow;
     /**
      * Читает path с регистрацией runtime reactive dependency.
      * @internal
      */
     _getTracked(): T | undefined;
+    /** Activates the lazy Kernel observer for an explicit granular watch. @internal */
+    _activate(): Disposer;
     private _readTracked;
     private _observe;
+    private _releaseObserverIfIdle;
     private _write;
     private _assertAlive;
 }

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

@@ -0,0 +1,32 @@
+import { RaphMetaWatchOptions } from '../../path/meta/meta.types';
+import { DataPathDef } from '../../path/path.types';
+import { Disposer } from '../../reactivity/types';
+import { RaphScope } from '../ownership/RaphScope';
+export type RaphMetaSourceOptions = RaphMetaWatchOptions;
+/** Immutable Runtime-owned metadata event source for explicit phase watches. */
+export declare class RaphMetaSource {
+    readonly owner: RaphScope;
+    private _start;
+    private _release;
+    readonly masks: DataPathDef | readonly DataPathDef[];
+    readonly options: Readonly<RaphMetaSourceOptions>;
+    private _stop;
+    private _activationLeases;
+    private _disposed;
+    private _releaseOwner;
+    /** @internal */
+    private constructor();
+    /** @internal */
+    static _create(owner: RaphScope, masks: DataPathDef | readonly DataPathDef[], options: RaphMetaSourceOptions, start: () => Disposer, release: () => void): RaphMetaSource;
+    get runtime(): import('../RaphRuntime').RaphRuntime;
+    get disposed(): boolean;
+    dispose(): void;
+    /** @internal */
+    _bindOwner(release: Disposer): void;
+    /** @internal */
+    _disposeOwned(): void;
+    /** @internal */
+    _activate(): Disposer;
+    /** @internal */
+    _assertAlive(): void;
+}

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