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

package/dist/raph.js

@@ -1,40 +1,48 @@
-import { DefaultDataAdapter as e } from "./debug/path/data-adapter.js";
-import { DataPath as t } from "./debug/path/data-path.js";
-import { collectionByKey as f, filterByKey as h, full as R } from "./debug/path/derived-strategies.js";
-import { RaphDerivedHandle as x, RaphDerivedTargetWriteError as i } from "./debug/path/RaphDerivedHandle.js";
-import { RaphKernel as n } from "./debug/path/RaphKernel.js";
-import { RaphMeta as u } from "./debug/path/RaphMeta.js";
-import { RaphActionError as D, RaphCrossRuntimeError as c, RaphDisposedError as y } from "./debug/runtime/errors.js";
-import { parentGraph as K } from "./debug/runtime/parent-graph.js";
-import { PathHandle as v } from "./debug/runtime/PathHandle.js";
-import { RaphSchedulerType as B } from "./debug/runtime/phase.types.js";
-import { RaphNode as H } from "./debug/runtime/RaphNode.js";
-import { RaphRuntime as P } from "./debug/runtime/RaphRuntime.js";
-import { RaphScope as T } from "./debug/runtime/RaphScope.js";
-import { RaphConfigurationError as N, RaphDefaultRuntimeError as W, RaphError as b, RaphModeError as j } from "./debug/api/errors.js";
-import { Raph as q } from "./debug/api/Raph.js";
+import { RaphCapabilityError as e, RaphConfigurationError as p, RaphDefaultInstanceError as a, RaphError as t, RaphFacadeDisposedError as h } from "./debug/api/errors.js";
+import { Raph as R } from "./debug/api/Raph.js";
+import { RaphReactivityInstance as x } from "./debug/api/RaphReactivityInstance.js";
+import { RaphActionError as n, RaphCrossRuntimeError as s, RaphDisposedError as c, RaphPhaseProcessError as l } from "./debug/runtime/errors.js";
+import { parentGraph as E } from "./debug/runtime/ownership/parentGraph.js";
+import { RaphEffectScope as u } from "./debug/runtime/ownership/RaphEffectScope.js";
+import { RaphNode as P } from "./debug/runtime/ownership/RaphNode.js";
+import { RaphScope as C } from "./debug/runtime/ownership/RaphScope.js";
+import { orderPhaseTasks as S } from "./debug/runtime/phases/orderPhaseTasks.js";
+import { RaphSchedulerType as g } from "./debug/runtime/phases/phase.types.js";
+import { RaphRuntime as B } from "./debug/runtime/RaphRuntime.js";
+import { PathHandle as I } from "./debug/runtime/reactivity/PathHandle.js";
+import { DataPath as k } from "./debug/path/DataPath.js";
+import { collectionByKey as G, filterByKey as M, full as N } from "./debug/path/derived/derived-strategy.utils.js";
+import { RaphDerivedHandle as j, RaphDerivedTargetWriteError as q } from "./debug/path/derived/RaphDerivedHandle.js";
+import { RaphMeta as z } from "./debug/path/meta/RaphMeta.js";
+import { RaphKernel as L } from "./debug/path/RaphKernel.js";
+import { DefaultDataAdapter as Q } from "./debug/path/storage/DefaultDataAdapter.js";
 export {
-  t as DataPath,
-  e as DefaultDataAdapter,
-  v as PathHandle,
-  q as Raph,
-  D as RaphActionError,
-  N as RaphConfigurationError,
-  c as RaphCrossRuntimeError,
-  W as RaphDefaultRuntimeError,
-  x as RaphDerivedHandle,
-  i as RaphDerivedTargetWriteError,
-  y as RaphDisposedError,
-  b as RaphError,
-  n as RaphKernel,
-  u as RaphMeta,
-  j as RaphModeError,
-  H as RaphNode,
-  P as RaphRuntime,
-  B as RaphSchedulerType,
-  T as RaphScope,
-  f as collectionByKey,
-  h as filterByKey,
-  R as full,
-  K as parentGraph
+  k as DataPath,
+  Q as DefaultDataAdapter,
+  I as PathHandle,
+  R as Raph,
+  n as RaphActionError,
+  e as RaphCapabilityError,
+  p as RaphConfigurationError,
+  s as RaphCrossRuntimeError,
+  a as RaphDefaultInstanceError,
+  j as RaphDerivedHandle,
+  q as RaphDerivedTargetWriteError,
+  c as RaphDisposedError,
+  u as RaphEffectScope,
+  t as RaphError,
+  h as RaphFacadeDisposedError,
+  L as RaphKernel,
+  z as RaphMeta,
+  P as RaphNode,
+  l as RaphPhaseProcessError,
+  x as RaphReactivityInstance,
+  B as RaphRuntime,
+  g as RaphSchedulerType,
+  C as RaphScope,
+  G as collectionByKey,
+  M as filterByKey,
+  N as full,
+  S as orderPhaseTasks,
+  E as parentGraph
 };

package/dist/reactivity/disposal.d.ts

@@ -0,0 +1,14 @@
+/** Failure of one completed disposal call; never thrown as a wrapper. @internal */
+export interface DisposalFailure {
+    readonly error: unknown;
+    readonly hasUnrouted: boolean;
+    readonly completed?: {
+        readonly error: unknown;
+    };
+}
+/** An authored callback or a non-resource disposal stage failed. @internal */
+export declare function unroutedDisposalFailure(error: unknown): DisposalFailure;
+/** Combines only errors collected by this framework operation, without inspecting payloads. @internal */
+export declare function combineDisposalFailures(failures: readonly DisposalFailure[] | undefined, message: string): DisposalFailure | undefined;
+/** Public disposal exposes only the original raw payload. @internal */
+export declare function throwDisposalFailure(failure: DisposalFailure | undefined): void;

package/dist/reactivity/engine.d.ts

@@ -1,4 +1,4 @@
-import { ComputedAccessHandle, Disposer, EffectCallback, EffectFactory, OwnedSource, ReactivityOptions, ReadonlySignal, Signal, SignalAccess, WatchCallback, WatchOptions, WatchSource, WritableComputedOptions } from './types';
+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';
@@ -9,12 +9,14 @@ export type { Disposer, EffectCallback, EffectScheduler, EffectTask, ReactivityO
  * синхронного движка не проверяет внешнюю политику на каждом эффекте.
  */
 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;
@@ -41,6 +43,11 @@ export declare class RaphReactivity {
      * а 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;
@@ -85,6 +92,8 @@ export declare class RaphReactivity {
      * Поля внешней задачи и окончательной очистки добавляются только при необходимости.
      */
     private allocateGraphRecord;
+    /** Creates a narrow Proxy adapter over the existing intrusive graph. */
+    private createReactivePropertySourceBridge;
     /**
      * Материализует signal в графе при первом отслеживаемом чтении
      * и связывает его с активным потребителем.
@@ -119,8 +128,9 @@ export declare class RaphReactivity {
     private writeSignalValue;
     /**
      * Возвращает кеш либо синхронно актуализирует вычисляемое значение.
-     * Неуспешное вычисление не считается значением. Даже ошибочное чтение сохраняет
-     * связь с активным потребителем, чтобы тот мог восстановиться при изменении источника.
+     * Неуспешное вычисление не считается значением. Ошибка getter сохраняет связь
+     * с активным потребителем для восстановления. Повторное чтение во время
+     * первого сбора зависимостей отклоняется до регистрации связи и чтения кеша.
      */
     private readComputedValue;
     /**
@@ -175,7 +185,7 @@ export declare class RaphReactivity {
     /**
      * Удаляет непрочитанный хвост зависимостей завершившегося запуска.
      * trackedTail обозначает границу прочитанного префикса, а не неизменный конец списка.
-     * Удаление из списков производителей не выполняет пользовательские callbacks.
+     * Ошибка cleanup не прерывает освобождение оставшегося хвоста зависимостей.
      */
     private pruneUnreadDependencies;
     /**
@@ -184,6 +194,10 @@ export declare class RaphReactivity {
      * Также исправляет курсор поиска, если он указывал на удаляемую связь.
      */
     private detachSubLink;
+    /** Завершает удаление producer-связи без вызова source cleanup. */
+    private unlinkSubLink;
+    /** Connects Runtime ownership metadata only for edges whose producer opted in. */
+    private attachDependencyCleanup;
     /**
      * Отсоединяет owned-источник сразу с обеих сторон каждой связи.
      * Вызывается на границе lifetime, а не при обычных чтениях и записях.
@@ -207,6 +221,7 @@ export declare class RaphReactivity {
      * не выполняет. Непосредственное и потенциальное изменения отмечает разными флагами.
      */
     private propagateInvalidation;
+    private markActiveChecks;
     /**
      * Помечает работающего потребителя, только если затронута уже прочитанная связь.
      * Связи за trackedTail принадлежат прошлому запуску и не означают повторную invalidation.
@@ -227,6 +242,8 @@ export declare class RaphReactivity {
      * Неверное значение в кеш не записывается.
      */
     private recomputeValue;
+    /** Сохраняет первичную ошибку и отдельные ошибки cleanup при восстановлении. */
+    private failComputedValue;
     /**
      * Восстанавливает связи и состояния после неудачного getter.
      * Отдельная функция удерживает обработку исключений вне обычной части пересчёта.
@@ -240,6 +257,8 @@ export declare class RaphReactivity {
      * узлов текущего прохода; порядок успешного обхода не меняется.
      */
     private refreshDependencies;
+    /** Settles every direct dependency so a cancelled external delivery can be re-armed. */
+    private settleCancelledDependencies;
     /**
      * Выполняет исходный итеративный обход зависимостей без обработки ошибок внутри цикла.
      * Перед пользовательским вычислением публикует активную высоту стека; оболочка
@@ -278,6 +297,7 @@ export declare class RaphReactivity {
      * Ошибка одного элемента не оставляет необработанные записи со старым SCHEDULED.
      */
     private flushExternalEffects;
+    private markRecoveryDependencies;
     /**
      * Завершает очередь после первой ошибки, собирая последующие причины сбоя.
      * Вызывается только на ошибочном пути; успешный проход не создаёт массив ошибок
@@ -290,6 +310,7 @@ export declare class RaphReactivity {
      * чтобы последующая запись могла снова запросить выполнение.
      */
     private requestEffectTask;
+    private scheduleEffectTask;
     /**
      * Окончательно останавливает эффект и освобождает все принадлежащие ему ресурсы.
      * Сначала делает узел неактивным и отсоединяет связи, затем отменяет задачу,
@@ -339,13 +360,13 @@ export declare class RaphReactivity {
      *
      * @internal
      */
-    _ownedSignal<T>(initialValue: T): OwnedSource<Signal<T>>;
+    _ownedSignal<T>(initialValue: T, sourceHooks?: OwnedSourceHooks): OwnedSource<Signal<T>>;
     /**
      * Создаёт ленивый computed с финализатором исходящих и входящих связей.
      * Финализатор работает и до первого вычисления, не материализуя узел ради очистки.
      * @internal
      */
-    _ownedComputed<T>(fn: () => T): OwnedSource<ReadonlySignal<T>>;
+    _ownedComputed<T>(fn: () => T, sourceHooks?: OwnedSourceHooks): OwnedSource<ReadonlySignal<T>>;
     /**
      * Открывает вложенную синхронную границу группировки.
      * Внутренний вызывающий код обязан выполнить соответствующий endBatch().
@@ -368,8 +389,174 @@ export declare class RaphReactivity {
      * @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'];
 export declare function computed<T>(getter: () => T): ReadonlySignal<T>;
 export declare function computed<T>(options: WritableComputedOptions<T>): Signal<T>;
 export declare const effect: RaphReactivity['effect'];

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

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

package/dist/reactivity/scope.d.ts

@@ -1,13 +1,26 @@
+import { DisposalFailure } from './disposal';
 import { RaphReactivity } from './engine';
 import { Disposer, EffectCallback, OwnedResource, OwnedSource, ReadonlySignal, ScopeChildren, ScopeLink, Signal, SourceFinalizer, WatchCallback, WatchOptions, WatchSource, WritableComputedOptions } from './types';
 /**
- * Универсальный владелец ресурсов без фаз, путей и зависимости от Runtime.
- * Хранит ресурсы в двусвязном списке и освобождает их в обратном порядке.
- * Проверки lifetime выполняют только owned handles; свободные signal() не проходят
- * через владельца. Класс не является узлом графа зависимостей.
+ * Запись источника в списке владельца: сама хранит связь с соседом и сама
+ * освобождает источник, поэтому владельцу не нужна отдельная коллекция.
+ * @internal
  */
-export declare class ScopeNode {
-    readonly reactivity: RaphReactivity;
+export interface OwnedSourceEntry {
+    _previousSource: OwnedSourceEntry | undefined;
+    _finalizeSource: () => boolean;
+}
+/**
+ * Общая основа владельцев: список ресурсов, список источников и признаки
+ * lifetime лежат в самом владельце. ScopeNode добавляет standalone API,
+ * RaphScope — Runtime API; отдельного объекта-хранилища у владельца нет.
+ *
+ * Поля объявлены через `declare` и присваиваются в constructor в одном
+ * порядке: все владельцы одного класса получают один hidden class, а сборка с
+ * любым target не превращает объявления в вызовы field-helper.
+ * @internal
+ */
+export declare abstract class ScopeOwner implements ScopeChildren<OwnedResource> {
     /**
      * Первый зарегистрированный ресурс; не является ребёнком execution-дерева.
      * @internal
@@ -19,14 +32,11 @@ export declare class ScopeNode {
      */
     scopeLastChild: OwnedResource | undefined;
     private _resourceCount;
-    private _sourceFinalizers;
+    private _lastSource;
+    private _sourceCount;
     protected _disposed: boolean;
     protected _disposing: boolean;
-    /**
-     * Связывает владельца с реактивным экземпляром без создания нового графа.
-     * @param reactivity Экземпляр, в котором создаются owned-ресурсы.
-     */
-    constructor(reactivity: RaphReactivity);
+    constructor();
     /**
      * Показывает, началось ли окончательное освобождение владельца.
      */
@@ -35,6 +45,88 @@ export declare class ScopeNode {
      * Разрешает регистрацию и доступ только до начала освобождения.
      */
     get active(): boolean;
+    /**
+     * Возвращает число ещё не освобождённых записей ресурсов.
+     * @internal
+     */
+    _debugResourceCount(): number;
+    /**
+     * Возвращает число зарегистрированных источников; после начала их
+     * финализации владелец источников не числит.
+     * @internal
+     */
+    _debugSourceCount(): number;
+    /**
+     * Возвращает последний зарегистрированный источник: с него по связям
+     * `_previousSource` обходится список источников владельца от нового к
+     * старому. С началом финализации владелец источников не числит, и метод
+     * возвращает undefined. Обход не должен регистрировать и освобождать
+     * источники этого владельца.
+     * @internal
+     */
+    _lastOwnedSource(): OwnedSourceEntry | undefined;
+    /**
+     * Вынимает запись ресурса из списка владельца и уменьшает счётчик. Запись
+     * вызывает метод из своего dispose() до пользовательского cleanup, иначе
+     * освобождение владельца не продвинется по списку. Повторный вызов и запись
+     * другого владельца безопасно игнорируются.
+     * @internal
+     */
+    _releaseRecord(entry: OwnedResource): void;
+    /**
+     * Ставит cleanup в конец списка ресурсов и возвращает его однократный stop.
+     * Lifetime не проверяет: это делает вызывающий метод владельца.
+     *
+     * Stop захватывает только запись, а не владельца: снятая запись теряет ссылку
+     * на владельца, поэтому удержанный stop не удерживает ни его, ни соседние
+     * записи.
+     */
+    protected _ownCleanup(cleanup: Disposer): Disposer;
+    /** Registers a framework cleanup; the public stop still exposes only raw failure. */
+    protected _ownCompleted(cleanup: () => DisposalFailure | undefined): Disposer;
+    /**
+     * Ставит готовую запись ресурса в конец списка без обёртки и closure: запись
+     * сама является элементом списка владельца. Её dispose() обязан сначала
+     * вызвать _releaseRecord(), иначе освобождение владельца не продвинется по
+     * списку. Предусловие: запись не состоит в другом списке.
+     * Lifetime не проверяет: это делает вызывающий метод владельца.
+     */
+    protected _ownRecord(entry: OwnedResource): void;
+    /**
+     * Ставит функцию-финализатор источника в список источников владельца.
+     * Lifetime не проверяет: это делает вызывающий метод владельца.
+     */
+    protected _ownSourceFinalizer(finalizer: SourceFinalizer): void;
+    /**
+     * Ставит готовую запись источника в список источников владельца без обёртки:
+     * источник сам является элементом списка и сам освобождает себя через
+     * _finalizeSource(). Предусловие: запись не состоит в другом списке.
+     * Lifetime не проверяет: это делает вызывающий метод владельца.
+     */
+    protected _ownSourceEntry(entry: OwnedSourceEntry): void;
+    /**
+     * Освобождает ресурсы в обратном порядке регистрации, затем финализирует
+     * источники. Сбой одной записи не останавливает остальные; массив ошибок
+     * создаётся только при первой ошибке.
+     */
+    protected _releaseOwned(): DisposalFailure[] | undefined;
+}
+/**
+ * Универсальный владелец ресурсов без фаз, путей и зависимости от Runtime.
+ * Хранит ресурсы в двусвязном списке и освобождает их в обратном порядке.
+ * Проверки lifetime выполняют только owned handles; свободные signal() не проходят
+ * через владельца. Класс не является узлом графа зависимостей.
+ */
+export declare class ScopeNode extends ScopeOwner {
+    /**
+     * Экземпляр, в котором создаются owned-ресурсы.
+     */
+    readonly reactivity: RaphReactivity;
+    /**
+     * Связывает владельца с реактивным экземпляром без создания нового графа.
+     * @param reactivity Экземпляр, в котором создаются owned-ресурсы.
+     */
+    constructor(reactivity: RaphReactivity);
     /**
      * Создаёт owned signal и регистрирует его финализатор.
      * Все методы возвращённого handle проверяют, что владелец ещё активен.
@@ -62,16 +154,6 @@ export declare class ScopeNode {
      * Если владелец уже неактивен, выполняет cleanup сразу и возвращает пустой disposer.
      */
     own(disposer: Disposer): Disposer;
-    /**
-     * Возвращает число ещё не освобождённых записей ресурсов.
-     * @internal
-     */
-    _debugResourceCount(): number;
-    /**
-     * Возвращает число зарегистрированных финализаторов источников.
-     * @internal
-     */
-    _debugSourceCount(): number;
     /**
      * Освобождает ресурсы в обратном порядке, затем финализирует источники.
      * Повторный вызов безопасен. Ошибки cleanup и завершающего hook собираются
@@ -100,6 +182,8 @@ export declare class ScopeNode {
     /**
      * Добавляет финализатор источника. Возвращённый им false означает повторную попытку
      * после прогресса других финализаторов, а не успешное освобождение.
+     * Каждая регистрация — отдельный источник: одинаковые финализаторы владелец
+     * не объединяет, и функция, переданная дважды, будет вызвана дважды.
      * @internal
      */
     _ownSource(finalizer: SourceFinalizer): void;
@@ -118,17 +202,11 @@ export declare class ScopeNode {
      * Возвращает сообщение для AggregateError при нескольких ошибках освобождения.
      */
     protected _disposalMessage(): string;
-    /**
-     * Освобождает источники в обратном порядке регистрации с повторными попытками.
-     * Если в проходе не было прогресса, прекращает обход, сохраняя существующий контракт.
-     * Исключение одного финализатора не блокирует остальные.
-     */
-    private _finalizeSources;
 }
 /**
  * Добавляет дочерний ресурс в конец списка владельца без отдельной обёртки связей.
- * Предусловие: ребёнок ещё не находится в другом списке. Переиспользуется
- * ресурсами ScopeNode и записями вложенных эффектов.
+ * Предусловие: ребёнок ещё не находится в другом списке. Используется записями
+ * вложенных эффектов; владельцы ведут свой список ресурсов сами.
  * @internal
  */
 export declare function appendScopeChild<T extends ScopeLink<T>>(parent: ScopeChildren<T>, child: T): void;