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

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

@@ -0,0 +1,309 @@
+import { Disposer, OwnedSourceHooks } from '../../reactivity/types';
+import { RaphNode } from '../ownership/RaphNode';
+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 = RaphProducer | RaphNode | RaphRuntime;
+interface WorkEdge {
+    readonly sink: WorkSink;
+    readonly kind: 'producer' | 'runtime' | 'self' | 'subtree';
+    source?: WorkEdgeSource;
+    activationRelease?: Disposer;
+    previous?: WorkEdge;
+    next?: WorkEdge;
+}
+interface WorkEdgeList {
+    first?: WorkEdge;
+    last?: WorkEdge;
+}
+type CleanupSource = RaphProducer | RaphNode | RaphAggregate;
+interface CleanupEdge {
+    cleanup?: () => void;
+    source?: CleanupSource;
+    previous?: CleanupEdge;
+    next?: CleanupEdge;
+}
+interface CleanupEdgeList {
+    first?: CleanupEdge;
+    last?: CleanupEdge;
+}
+interface AggregateSubscription {
+    dispose?: (finalCause?: RaphWorkCause) => void;
+    aggregate?: RaphAggregate;
+    previous?: AggregateSubscription;
+    next?: AggregateSubscription;
+}
+interface ProducerOptions {
+    readonly includeRuntime?: boolean;
+}
+/** @internal */
+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: RaphProducerKind;
+    readonly includeRuntime: boolean;
+    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 {
+    readonly owner: RaphScope;
+    private _sources;
+    private _disposed;
+    private _releaseOwner;
+    private _memberReleases;
+    private _firstSubscription;
+    private _lastSubscription;
+    private _firstDependent;
+    private _lastDependent;
+    private _revision;
+    private _finalCause;
+    /** @internal */
+    private constructor();
+    /** @internal */
+    static _create(owner: RaphScope, sources: readonly RaphAggregateSource[]): RaphAggregate;
+    get runtime(): RaphRuntime;
+    get disposed(): boolean;
+    get sources(): readonly RaphAggregateSource[];
+    dispose(): void;
+    /** @internal */
+    _assertAlive(): void;
+    /** @internal */
+    _bindOwner(release: () => void): void;
+    /** @internal */
+    _bindMembers(releases: Array<() => void>): void;
+    /** @internal */
+    _removeMember(identity: object): void;
+    /** @internal */
+    _disposeOwned(): void;
+    /** @internal */
+    _linkSubscription(dispose: (finalCause?: RaphWorkCause) => void): () => void;
+    /** @internal */
+    _linkDependent(edge: CleanupEdge): void;
+    /** @internal */
+    _detachDependent(edge: CleanupEdge): void;
+    /** @internal */
+    _disposalCause(): RaphWorkCause;
+    /** @internal */
+    _detachSubscription(subscription: AggregateSubscription): void;
+}
+/** 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;
+    private _runtimeSubscriberCount;
+    private _runtimeActivationProducers;
+    private _nodeMemberships;
+    private _nodeRevisions;
+    private _nodeTouchKeys;
+    private _implicitProducers;
+    private _transientProducers;
+    private _dispatchDepth;
+    private _detachedEdges;
+    private _disposed;
+    constructor(_runtime: RaphRuntime);
+    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: 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;
+        readonly oldAncestors?: readonly RaphNode[];
+        readonly newAncestors?: readonly RaphNode[];
+    }): void;
+    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.
+     *
+     * Рёбра от 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;
+    /**
+     * Освобождает 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;
+    /**
+     * Учитывает одно фактическое 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;
+    private _linkSourceCleanup;
+    private _detachCleanupEdge;
+    private _releaseCleanupList;
+    private _validateAggregateSources;
+    private _assertSourceVisibleTo;
+    private _assertProvisionalOwnerAccess;
+    private _dispatch;
+    private _appendWorkEdge;
+    private _detachWorkEdge;
+    private _releaseWorkList;
+    private _releaseGranule;
+    private _setTransientCause;
+    private _producerHasDemand;
+    private _nodeTouchKey;
+    private _nodeHasDemand;
+    private _assertOwner;
+    private _assertRuntime;
+    private _assertAlive;
+}
+export {};

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

@@ -0,0 +1,293 @@
+import { OwnedSourceEntry } from '../../reactivity/scope';
+import { EffectCallback, OwnedSourceHooks, ReactiveNode, ReactivityOptions, ReadonlySignal, Signal } from '../../reactivity/types';
+import { RaphScope } from '../ownership/RaphScope';
+import { RaphSelectorOptions, RuntimeSelector } from './RaphSelector';
+import { RaphProducerDescription, RaphProducerKind, RaphProducer } from './RaphWorkGraph';
+import { ReleasedGraphShapes, RuntimeSignalLifecycle, RuntimeSignalWriteTap } from './runtime-reactivity.types';
+import { RaphReactivity } from '../../reactivity/engine';
+/**
+ * Компактное описание Runtime signal, которое возвращает его toJSON().
+ *
+ * @internal
+ */
+export interface RuntimeSignalDescription extends RaphProducerDescription {
+    readonly index: number;
+}
+/**
+ * Наибольший номер, который toJSON() Runtime signal считает точно. Номер
+ * считается проходом по списку источников владельца, и граница делает цену
+ * одного описания постоянной: сериализация всех signals одного владельца
+ * линейна по их числу, а не квадратична.
+ *
+ * @internal
+ */
+export declare const SIGNAL_INDEX_LIMIT = 64;
+/**
+ * Runtime signal одним объектом: публичный handle, producer WorkGraph, source
+ * hooks своей записи графа и запись в списке источников владельца. Методы
+ * лежат на prototype, поэтому signal не создаёт ни одной closure; get, peek и
+ * set нужно вызывать через handle или с явным receiver.
+ *
+ * Значение лежит в самом signal до первого отслеживаемого чтения. Оно
+ * материализует запись графа, и дальше значением владеет запись.
+ *
+ * Поля объявлены через `declare` и присваиваются в constructor в одном порядке
+ * вслед за полями RaphProducer: у всех signals один hidden class.
+ */
+export declare class RuntimeSignal<T> extends RaphProducer implements Signal<T>, OwnedSourceHooks, OwnedSourceEntry {
+    private _value;
+    private _node;
+    /**
+     * Источник, зарегистрированный у владельца перед этим.
+     * @internal
+     */
+    _previousSource: OwnedSourceEntry | undefined;
+    private _writeTaps;
+    /**
+     * Создаёт signal своим собственным handle. Регистрацию у владельца
+     * выполняет вызывающий код.
+     */
+    constructor(owner: RaphScope, kind: RaphProducerKind, includeRuntime: boolean, value: T);
+    /**
+     * Identity producer для задач implicit effects: сам signal.
+     * @internal
+     */
+    get token(): this;
+    /**
+     * Владелец signal. Engine читает это поле только у потребителей, а signal
+     * потребителем не бывает; getter сохраняет полный контракт source hooks.
+     * @internal
+     */
+    get dependencyOwner(): RaphScope;
+    /**
+     * Возвращает компактное описание signal для JSON.stringify, логов и diff
+     * неуспешной проверки. К описанию producer добавлен номер signal среди
+     * источников его владельца в порядке регистрации: один и тот же signal
+     * описывается одинаково, сколько бы раз и через какую копию его ни
+     * печатали, а разные живые signals одного владельца различаются номером,
+     * пока он меньше SIGNAL_INDEX_LIMIT. Номер считается проходом по списку
+     * источников только при сериализации и не дальше этой границы: у каждого
+     * источника, зарегистрированного после первых SIGNAL_INDEX_LIMIT, он равен
+     * границе. У освобождённого signal номер равен нулю. Значение в описание не
+     * входит: оно может быть сколь угодно большим и само содержать циклы.
+     */
+    toJSON(): RuntimeSignalDescription;
+    /**
+     * Читает значение и регистрирует зависимость активного потребителя.
+     */
+    get(): T;
+    /**
+     * Читает значение без подписки текущего потребителя.
+     */
+    peek(): T;
+    /**
+     * Записывает значение в собственной границе записи Runtime. Граница
+     * открывается и закрывается явными вызовами, без closure.
+     */
+    set(value: T): void;
+    /**
+     * Записывает значение внутри уже открытой границы записи, минуя политику
+     * actions: так Runtime продвигает собственный frame signal.
+     * @internal
+     */
+    _writeInBoundary(value: T): void;
+    /**
+     * Подключает наблюдателя фактических записей этого signal. Наблюдатель
+     * вызывается синхронно внутри границы записи, после того как новое значение
+     * стало видимым для чтения, и до выхода из записи. Запись, которая уже идёт,
+     * нового наблюдателя не вызывает. Цена подключения не зависит от числа
+     * наблюдателей.
+     * @internal
+     */
+    _addWriteTap(tap: RuntimeSignalWriteTap): void;
+    /**
+     * Отключает наблюдателя записей: его место занимает последний наблюдатель
+     * списка. Запись, которая уже идёт, ещё вызовет отключённого наблюдателя.
+     * Отключение неизвестного наблюдателя и отключение у освобождённого signal
+     * безопасны. Цена отключения не зависит от числа наблюдателей.
+     * @internal
+     */
+    _removeWriteTap(tap: RuntimeSignalWriteTap): void;
+    /**
+     * Сообщает WorkGraph о фактической записи до распространения по графу.
+     * @internal
+     */
+    onChange(previous: unknown, value: unknown, hasReactiveSubscribers: boolean): void;
+    /**
+     * Освобождает producer-сторону signal в WorkGraph.
+     * @internal
+     */
+    onDispose(hasReactiveSubscribers: boolean): void;
+    /**
+     * Ищет среди текущих потребителей signal в графе первого, чьего владельца
+     * принимает accept, и возвращает этого владельца. Signal не ведёт учёта
+     * своих implicit-рёбер и не имеет hook onDependency: рёбра читаются из
+     * записи графа только по запросу. У signal без записи графа потребителей
+     * нет: его ещё не читал ни один потребитель либо он уже освобождён.
+     * Владельцы наблюдателей записи считаются потребителями наравне с ними.
+     * @internal
+     */
+    _findConsumerOwner<Context>(accept: (consumerOwner: object, context: Context) => boolean, context: Context): object | undefined;
+    /**
+     * Освобождает signal как источник владельца: публикует финальную причину,
+     * отсоединяет запись графа и отпускает значение. Сбой одного шага не
+     * отменяет остальные. Повторный вызов безопасен.
+     * @internal
+     */
+    _finalizeSource(): boolean;
+    /**
+     * Записывает значение без проверок lifetime и без границы записи.
+     * Критерий изменения — ===, как у записи графа.
+     */
+    private _write;
+    /**
+     * Запись signal с наблюдателями. Отличается от `_write()` двумя вещами.
+     * Причина записи публикуется и тогда, когда потребители есть только у
+     * наблюдателя: их будит эта же запись. После того как новое значение стало
+     * видимым, каждый наблюдатель получает прежнее и новое значение. Сбой
+     * распространения по графу или одного наблюдателя не отменяет остальных.
+     *
+     * Запись обходит тот список наблюдателей, который застала: подключение и
+     * отключение во время обхода меняют его копию.
+     */
+    private _writeTapped;
+}
+/**
+ * Внутренний policy adapter, наследующий реактивные алгоритмы без дублирования.
+ */
+export declare class RuntimeReactivity extends RaphReactivity {
+    /** @internal */
+    readonly _lifecycle: RuntimeSignalLifecycle;
+    /**
+     * Удерживает формы, которые записи графа получают только при освобождении.
+     * Создаётся первым графом Runtime в isolate и дальше не заменяется.
+     * @internal
+     */
+    static _releasedShapeAnchor: ReleasedGraphShapes | undefined;
+    /**
+     * Тело записи engine каждого implicit phase effect этого графа: одна
+     * функция на граф, а не closure на binding. Engine вызывает тело без
+     * аргументов, поэтому свой binding оно берёт у engine: запись исполняемого
+     * effect — активный потребитель, а её задача — запись binding. Регистрация
+     * binding поэтому не выделяет ни closure, ни context, а запуск тела, которое
+     * не вернуло cleanup, не выделяет ничего.
+     *
+     * Тело binding вызывается с его consumer owner в качестве активного
+     * Runtime-контекста; контекст возвращается и после сбоя тела. Что получает
+     * тело, решает запись: frozen task либо, под `TASK_TASKLESS`, поле `group` —
+     * запуск slot у группы и `undefined` у binding без task, facade которого при
+     * этом не создаётся. Возвращённый cleanup выполняется вне любого
+     * Runtime-контекста.
+     *
+     * Вызывать функцию вправе только engine как тело записи, созданной через
+     * `_allocateTaskEffect()` с записью binding в роли задачи.
+     *
+     * @internal
+     */
+    readonly _phaseBody: EffectCallback;
+    /**
+     * Создаёт policy adapter реактивного графа для одного runtime.
+     * @param _lifecycle Политика lifetime и записи Runtime; её читают handles
+     * этого графа, поэтому поле доступно внутри пакета.
+     */
+    constructor(
+    /** @internal */
+    _lifecycle: RuntimeSignalLifecycle, options?: Pick<ReactivityOptions, 'adaptiveDependencyIndex'>);
+    /**
+     * Выполняет untracked-операцию, сохраняя runtime owner context.
+     */
+    untrackedWithOwner<T>(operation: () => T): T;
+    /**
+     * Вызывает операцию с её аргументами вне Runtime owner context и вне graph
+     * consumer: форма `untrackedWithOwner(() => operation(...args))` без closure.
+     * Closure создаётся, только когда вызов пришёл изнутри отслеживаемого
+     * вычисления и graph consumer нужно снять.
+     *
+     * @internal
+     */
+    _applyUntrackedWithOwner<Args extends unknown[], Result>(operation: (...args: Args) => Result, args: Args): Result;
+    /**
+     * Выполняет одну открытую доставку phase effect вне Runtime owner context и
+     * вне graph consumer: форма untrackedWithOwner() без closure для записи,
+     * подготовленной через _beginTaskEffectRun().
+     *
+     * @internal
+     */
+    _runTaskEffectUntracked(node: ReactiveNode): void;
+    /**
+     * Возвращает owner текущего синхронного реактивного контекста.
+     */
+    getActiveOwner(): object | undefined;
+    /** Returns the Runtime resource owner whose implicit dependencies are being collected. */
+    getActiveConsumerOwner(): RaphScope | undefined;
+    /**
+     * Сообщает, должен ли untracked work очищать graph consumer или Runtime owner context.
+     */
+    hasActiveContext(): boolean;
+    /**
+     * Выполняет операцию с указанным active owner.
+     */
+    runWithOwner<T>(lifecycle: RuntimeSignalLifecycle | undefined, consumerOwner: RaphScope | undefined, operation: () => T): T;
+    /**
+     * Ищет среди текущих потребителей Runtime signals владельца `sourceOwner`
+     * первого, чьего владельца принимает accept, и возвращает этого владельца.
+     * Signals обходятся от нового к старому по списку источников владельца;
+     * остальные источники списка пропускаются: их рёбра учитывает сам WorkGraph.
+     * Обход ничего не выделяет. Его цена — длина списка источников владельца
+     * плюс потребители каждого его signal с записью графа до первого принятого.
+     *
+     * @internal
+     */
+    _findSignalConsumerOwner<Context>(sourceOwner: RaphScope, accept: (consumerOwner: object, context: Context) => boolean, context: Context): object | undefined;
+    /**
+     * Проверяет отслеживаемое чтение источника владельца `sourceOwner` теми же
+     * правилами, что и чтение его Runtime signal: Runtime жив, активный
+     * потребитель принадлежит этому Runtime и вправе неявно зависеть от
+     * владельца. Lifetime самого владельца проверяет вызывающий код.
+     *
+     * @internal
+     */
+    _assertTrackedRead(sourceOwner: RaphScope): void;
+    /**
+     * Сообщает, что у записи ровно один потребитель. Внутри cleanup связи,
+     * который engine вызывает до снятия этой связи со списка, ответ `true`
+     * означает, что снимается последняя связь записи.
+     *
+     * @internal
+     */
+    _hasSingleSubscriber(node: ReactiveNode): boolean;
+    /**
+     * Считает записи, у которых есть потребители, в двух частях одного индекса:
+     * в ряду, где пустое место хранит undefined, и в индексе по ключам, если он
+     * есть. Ряд обходится циклом без вызовов. Обход ничего не выделяет и не
+     * меняет граф.
+     *
+     * @internal
+     */
+    _countObserved(row: readonly (ReactiveNode | undefined)[], index: Map<unknown, ReactiveNode> | undefined): number;
+    /**
+     * Убирает записи без потребителей из обеих частей индекса: место ряда
+     * становится пустым, запись индекса по ключам удаляется. Возвращает число
+     * мест ряда, оставшихся занятыми. Сами записи не освобождаются: без
+     * потребителей и без ссылки из индекса они недостижимы.
+     *
+     * @internal
+     */
+    _dropUnobserved(row: (ReactiveNode | undefined)[], index: Map<unknown, ReactiveNode> | undefined): number;
+    /**
+     * Создаёт selector над записываемым Runtime signal и ставит его в список
+     * источников владельца. Source должен быть доступен владельцу для implicit
+     * чтения: принадлежать ему самому, его предку или root scope. Тогда source
+     * переживает selector, а потребители selector могли бы читать source сами.
+     */
+    selectorForOwner<Key>(source: Signal<Key>, owner: RaphScope, options?: RaphSelectorOptions<Key>): RuntimeSelector<Key>;
+    /**
+     * Создаёт Runtime signal и ставит его в список источников владельца. Signal
+     * одним объектом является handle, producer WorkGraph и записью источника.
+     */
+    signalForOwner<T>(initialValue: T, owner: RaphScope, kind?: RaphProducerKind, includeRuntime?: boolean): RuntimeSignal<T>;
+    /**
+     * Создаёт owned computed с runtime lifecycle policy.
+     */
+    computedForOwner<T>(getter: () => T, owner: RaphScope, sourceHooks?: OwnedSourceHooks): ReadonlySignal<T>;
+}

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

@@ -1,25 +1,31 @@
-import { Disposer } from '../reactivity/types';
+import { Disposer } from '../../reactivity/types';
 /**
  * Хранит общий callback/cleanup lifecycle Runtime-watch без знания источника
  * событий. Регистрация в Kernel и фазовая доставка остаются у Runtime.
+ *
+ * Поля объявлены без initializers и присваиваются в constructor в одном
+ * фиксированном порядке: у каждого watch, включая наследников, один hidden
+ * class, и ни один build target не превращает поля в вызовы helper.
  */
 export declare class RuntimeWatch {
-    private readonly _runUntracked;
     private _cleanup;
     private _stopped;
+    private readonly _runUntracked;
+    private readonly _callback;
+    readonly deliver: () => void;
     /**
      * Создаёт runtime-owned watch с явным lifecycle остановки.
      */
-    constructor(_runUntracked: <T>(operation: () => T) => T);
+    constructor(runUntracked: <T>(operation: () => T) => T, callback: () => void | Disposer);
     /**
      * Показывает, остановлен ли watch.
      */
     get stopped(): boolean;
     /**
-     * Освобождает предыдущий результат callback и выполняет новую доставку.
-     * Ошибка cleanup не лишает живой watcher текущего события.
+     * Preserves cleanup/callback error aggregation and reentrant stop semantics
+     * for the less common resource-returning callback path.
      */
-    deliver(callback: () => void | Disposer): void;
+    private _deliverWithCleanup;
     /**
      * Останавливает внешнюю регистрацию и cleanup callback, сохраняя обе ошибки.
      */

package/dist/runtime/reactivity/disposal-sweep.utils.d.ts

@@ -0,0 +1,19 @@
+import { RuntimeDisposalSweeper } from './runtime-reactivity.types';
+/**
+ * Ставит участника в очередь со сроком `due`.
+ *
+ * @internal
+ */
+export declare function enqueueSweeper(queue: RuntimeDisposalSweeper[], sweeper: RuntimeDisposalSweeper, due: number): void;
+/**
+ * Убирает участника из очереди. Возвращает false, если участника в ней нет.
+ *
+ * @internal
+ */
+export declare function dequeueSweeper(queue: RuntimeDisposalSweeper[], sweeper: RuntimeDisposalSweeper): boolean;
+/**
+ * Назначает ближайшему участнику очереди новый срок не раньше прежнего.
+ *
+ * @internal
+ */
+export declare function postponeFirstSweeper(queue: RuntimeDisposalSweeper[], due: number): void;