@raphy-js/raph 1.0.0-dev.2

package/dist/path/derived-strategies.d.ts

@@ -0,0 +1,15 @@
+export interface DerivedFullStrategy {
+    readonly kind: 'full';
+}
+export interface DerivedCollectionByKeyStrategy {
+    readonly kind: 'collection-by-key';
+    readonly key: string;
+}
+export interface DerivedFilterByKeyStrategy {
+    readonly kind: 'filter-by-key';
+    readonly key: string;
+}
+export type DerivedStrategy = DerivedFullStrategy | DerivedCollectionByKeyStrategy | DerivedFilterByKeyStrategy;
+export declare function full(): DerivedFullStrategy;
+export declare function collectionByKey(key: string): DerivedCollectionByKeyStrategy;
+export declare function filterByKey(key: string): DerivedFilterByKeyStrategy;

package/dist/path/meta.types.d.ts

@@ -0,0 +1,33 @@
+import { DataPath } from './data-path';
+import { DataPathDef, PathOptions } from './path.types';
+export type RaphMetaMutationKind = 'set' | 'merge' | 'delete';
+export type RaphMetaMutationCause = 'explicit' | 'owner-delete' | 'owner-replaced';
+export interface RaphMetaMutationEvent {
+    readonly kind: RaphMetaMutationKind;
+    readonly path: DataPath;
+    readonly namespace: string | null;
+    readonly cause: RaphMetaMutationCause;
+}
+export interface RaphMetaEvents {
+    readonly events: readonly RaphMetaMutationEvent[];
+}
+export interface RaphMetaReadOptions extends PathOptions {
+}
+export interface RaphMetaWriteOptions extends RaphMetaReadOptions {
+    readonly invalidate?: boolean;
+}
+export interface RaphMetaWatchOptions extends RaphMetaReadOptions {
+    readonly namespace?: string;
+    readonly wildcardDynamic?: boolean;
+    readonly phase?: string;
+    readonly priority?: number;
+}
+export type RaphMetaWatchCallback = (payload: RaphMetaEvents) => void | (() => void);
+export interface RaphMetaApi {
+    get: (path: DataPathDef, namespace?: string, options?: RaphMetaReadOptions) => unknown;
+    has: (path: DataPathDef, namespace?: string, options?: RaphMetaReadOptions) => boolean;
+    set: (path: DataPathDef, namespace: string, value: unknown, options?: RaphMetaWriteOptions) => void;
+    merge: (path: DataPathDef, namespace: string, value: unknown, options?: RaphMetaWriteOptions) => void;
+    delete: (path: DataPathDef, namespace?: string, options?: RaphMetaWriteOptions) => void;
+    watch: (masks: DataPathDef | readonly DataPathDef[], callback: RaphMetaWatchCallback, options?: RaphMetaWatchOptions) => () => void;
+}

package/dist/path/path-router.d.ts

@@ -0,0 +1,21 @@
+import { ParsedPathMask, PathSegment } from './data-path';
+/**
+ * Индексирует exact и wildcard path-masks без участия reactive graph.
+ */
+export declare class PathRouter<Payload> {
+    private readonly _root;
+    /**
+     * Регистрирует route mask и возвращает функцию удаления.
+     */
+    add(mask: ParsedPathMask, payload: Payload): () => void;
+    /**
+     * Возвращает routes, чьи masks соответствуют указанному событию.
+     */
+    match(path: readonly Exclude<PathSegment, {
+        kind: 'wildcard';
+    }>[]): Set<Payload>;
+    /**
+     * При замене root возвращает все зарегистрированные path masks.
+     */
+    matchAll(): Set<Payload>;
+}

package/dist/path/path.types.d.ts

@@ -0,0 +1,26 @@
+import { DataPath, PlainDataPath } from './data-path';
+export type DataPathDef = string | DataPath | PlainDataPath;
+export interface PathOptions {
+    readonly vars?: Readonly<Record<string, unknown>>;
+}
+export type PathMutationKind = 'set' | 'merge' | 'delete';
+export interface PathEvent {
+    readonly kind: PathMutationKind;
+    readonly path: string;
+    readonly previous: unknown;
+    readonly value: unknown;
+}
+export interface PathEvents {
+    readonly events: readonly PathEvent[];
+}
+export type PathWatchCallback = (payload: PathEvents) => void;
+export interface PathApi {
+    get: <T = unknown>(path: DataPathDef, options?: PathOptions) => T | undefined;
+    peek: <T = unknown>(path: DataPathDef, options?: PathOptions) => T | undefined;
+    has: (path: DataPathDef, options?: PathOptions) => boolean;
+    set: <T>(path: DataPathDef, value: T, options?: PathOptions) => void;
+    merge: (path: DataPathDef, value: unknown, options?: PathOptions) => void;
+    delete: (path: DataPathDef, options?: PathOptions) => void;
+    transaction: <T>(operation: () => T) => T;
+    watch: (masks: DataPathDef | readonly DataPathDef[], callback: PathWatchCallback) => () => void;
+}

package/dist/path/public.d.ts

@@ -0,0 +1,14 @@
+export { DefaultDataAdapter } from './data-adapter';
+export type { DataAdapter, DataObject, DefaultAdapterOptions, } from './data-adapter';
+export { DataPath } from './data-path';
+export type { DataPathParseOptions, PathScalar, PathSegment, PlainDataPath, } from './data-path';
+export { collectionByKey, filterByKey, full } from './derived-strategies';
+export type { DerivedCollectionByKeyStrategy, DerivedFilterByKeyStrategy, DerivedFullStrategy, DerivedStrategy, } from './derived-strategies';
+export type { RaphMetaApi, RaphMetaEvents, RaphMetaMutationCause, RaphMetaMutationEvent, RaphMetaMutationKind, RaphMetaReadOptions, RaphMetaWatchCallback, RaphMetaWatchOptions, RaphMetaWriteOptions, } from './meta.types';
+export type { DataPathDef, PathApi, PathEvent, PathEvents, PathMutationKind, PathOptions, PathWatchCallback, } from './path.types';
+export { PathStore } from './PathStore';
+export { RaphDerivedHandle } from './RaphDerivedHandle';
+export type { DerivedOptions } from './RaphDerivedHandle';
+export { RaphKernel } from './RaphKernel';
+export type { RaphKernelOptions, RaphKernelRoot, RaphKernelRuntime, } from './RaphKernel';
+export { RaphMeta } from './RaphMeta';

package/dist/path/segment-key.d.ts

@@ -0,0 +1,2 @@
+import { PathSegment } from './data-path';
+export declare function pathSegmentKey(segment: PathSegment): string;

package/dist/path.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("./debug/path/data-adapter.cjs"),a=require("./debug/path/data-path.cjs"),e=require("./debug/path/derived-strategies.cjs"),r=require("./debug/path/PathStore.cjs"),d=require("./debug/path/RaphDerivedHandle.cjs"),h=require("./debug/path/RaphKernel.cjs"),l=require("./debug/path/RaphMeta.cjs");exports.DefaultDataAdapter=t.DefaultDataAdapter;exports.DataPath=a.DataPath;exports.collectionByKey=e.collectionByKey;exports.filterByKey=e.filterByKey;exports.full=e.full;exports.PathStore=r.PathStore;exports.RaphDerivedHandle=d.RaphDerivedHandle;exports.RaphKernel=h.RaphKernel;exports.RaphMeta=l.RaphMeta;

package/dist/path.js

@@ -0,0 +1,18 @@
+import { DefaultDataAdapter as o } from "./debug/path/data-adapter.js";
+import { DataPath as a } from "./debug/path/data-path.js";
+import { collectionByKey as f, filterByKey as l, full as m } from "./debug/path/derived-strategies.js";
+import { PathStore as h } from "./debug/path/PathStore.js";
+import { RaphDerivedHandle as D } from "./debug/path/RaphDerivedHandle.js";
+import { RaphKernel as i } from "./debug/path/RaphKernel.js";
+import { RaphMeta as K } from "./debug/path/RaphMeta.js";
+export {
+  a as DataPath,
+  o as DefaultDataAdapter,
+  h as PathStore,
+  D as RaphDerivedHandle,
+  i as RaphKernel,
+  K as RaphMeta,
+  f as collectionByKey,
+  l as filterByKey,
+  m as full
+};

package/dist/raph.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const p=require("./debug/path/data-adapter.cjs"),o=require("./debug/path/data-path.cjs"),r=require("./debug/path/derived-strategies.cjs"),t=require("./debug/path/RaphDerivedHandle.cjs"),h=require("./debug/path/RaphKernel.cjs"),u=require("./debug/path/RaphMeta.cjs"),a=require("./debug/runtime/errors.cjs"),i=require("./debug/runtime/parent-graph.cjs"),n=require("./debug/runtime/PathHandle.cjs"),R=require("./debug/runtime/phase.types.cjs"),d=require("./debug/runtime/RaphNode.cjs"),_=require("./debug/runtime/RaphRuntime.cjs"),s=require("./debug/runtime/RaphScope.cjs"),e=require("./debug/api/errors.cjs"),c=require("./debug/api/Raph.cjs");exports.DefaultDataAdapter=p.DefaultDataAdapter;exports.DataPath=o.DataPath;exports.collectionByKey=r.collectionByKey;exports.filterByKey=r.filterByKey;exports.full=r.full;exports.RaphDerivedHandle=t.RaphDerivedHandle;exports.RaphDerivedTargetWriteError=t.RaphDerivedTargetWriteError;exports.RaphKernel=h.RaphKernel;exports.RaphMeta=u.RaphMeta;exports.RaphActionError=a.RaphActionError;exports.RaphCrossRuntimeError=a.RaphCrossRuntimeError;exports.RaphDisposedError=a.RaphDisposedError;exports.parentGraph=i.parentGraph;exports.PathHandle=n.PathHandle;exports.RaphSchedulerType=R.RaphSchedulerType;exports.RaphNode=d.RaphNode;exports.RaphRuntime=_.RaphRuntime;exports.RaphScope=s.RaphScope;exports.RaphConfigurationError=e.RaphConfigurationError;exports.RaphDefaultRuntimeError=e.RaphDefaultRuntimeError;exports.RaphError=e.RaphError;exports.RaphModeError=e.RaphModeError;exports.Raph=c.Raph;

package/dist/raph.js

@@ -0,0 +1,40 @@
+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";
+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
+};

package/dist/reactivity/engine.d.ts

@@ -0,0 +1,379 @@
+import { ComputedAccessHandle, Disposer, EffectCallback, EffectFactory, OwnedSource, ReactivityOptions, ReadonlySignal, Signal, SignalAccess, WatchCallback, WatchOptions, WatchSource, WritableComputedOptions } from './types';
+import { ScopeNode } from './scope';
+export { ScopeNode } from './scope';
+export type { Disposer, EffectCallback, EffectScheduler, EffectTask, ReactivityOptions, ReadonlySignal, Signal, WatchCallback, WatchOptions, WatchSource, WatchValue, WritableComputedOptions, } from './types';
+/**
+ * Изолированный граф реактивности с синхронным исполнением по умолчанию.
+ * Состояние принадлежит полям экземпляра, алгоритмы - обычным методам прототипа.
+ * Только передаваемые наружу методы связаны с экземпляром один раз; очередь
+ * синхронного движка не проверяет внешнюю политику на каждом эффекте.
+ */
+export declare class RaphReactivity {
+    private activeSub;
+    private batchDepth;
+    private effectReadIndex;
+    private effectWriteIndex;
+    private invalidationDepth;
+    private dependencyDepth;
+    private flushingEffects;
+    private readonly effectQueue;
+    private readonly invalidationStack;
+    private readonly dependencyStack;
+    private readonly handleReaders;
+    private readonly effectScheduler;
+    private readonly flushEffects;
+    /**
+     * Синхронная регистрация эффекта для Runtime и watch независимо от внешней политики.
+     * Это связанная ссылка на реализацию effect(), а не делегирующая функция.
+     * @internal
+     */
+    readonly _effectImmediate: EffectFactory;
+    /**
+     * Выбирает политику исполнения и сохраняет совместимость извлечённых методов.
+     * Тела методов находятся на прототипе; bind() выполняется только при создании
+     * экземпляра, чтобы Runtime и глобальный API могли передавать методы как callbacks.
+     * @param options Необязательная внешняя политика эффектов.
+     */
+    constructor(options?: ReactivityOptions);
+    /**
+     * Создаёт объектный signal с get/peek/set.
+     * get() регистрирует зависимость только при активном потребителе,
+     * а peek() выполняет чтение с временно отключённым отслеживанием.
+     */
+    signal<T>(initialValue: T): Signal<T>;
+    /**
+     * - `(1)` Создаёт ленивое вычисляемое значение только для чтения;
+     * - `(2)` Создаёт writable computed, сохраняя исходную функцию setter;
+     * - `(3)` Создаёт ленивое вычисляемое значение; для объекта get/set сохраняет;
+     * исходную функцию записи без дополнительной обёртки.
+     */
+    computed<T>(getter: () => T): ReadonlySignal<T>;
+    computed<T>(options: WritableComputedOptions<T>): Signal<T>;
+    /**
+     * Создаёт эффект согласно политике экземпляра и возвращает disposer.
+     * Прототип содержит синхронную реализацию; при наличии scheduler конструктор
+     * подставляет createScheduledEffect, сохраняя этот путь как _effectImmediate.
+     * Вложенный эффект включается в список ресурсов активного эффекта.
+     * При ошибке регистрации удаляет созданные ресурсы, сохраняя обе причины сбоя.
+     * @param fn Синхронное тело с необязательным cleanup очередного запуска.
+     * @param onStop Однократная окончательная очистка, независимая от повторных запусков.
+     */
+    effect(fn: EffectCallback, onStop?: Disposer): Disposer;
+    /**
+     * Наблюдает за источниками; callback и cleanup не создают зависимостей.
+     */
+    watch<S extends WatchSource | readonly WatchSource[]>(source: S, callback: WatchCallback<S>, options?: WatchOptions): Disposer;
+    /**
+     * Группирует синхронные записи и обрабатывает эффекты после внешней границы.
+     * Возвращает результат операции. Если тело и очередь завершаются с ошибками,
+     * передаёт обе ошибки в AggregateError вместо потери первой. Не является откатом данных.
+     */
+    batch<T>(fn: () => T): T;
+    /**
+     * Выполняет синхронную операцию без добавления зависимостей текущему потребителю.
+     * Восстанавливает прежний контекст и при исключении. Асинхронное продолжение
+     * операции этим контекстом не охватывается.
+     */
+    untracked<T>(fn: () => T): T;
+    /**
+     * Создаёт владельца ресурсов в текущем графе без Runtime и фаз.
+     */
+    scope(): ScopeNode;
+    /**
+     * Создаёт запись графа с одинаковым порядком основных полей.
+     * Значение служит кешем signal/computed либо хранит cleanup эффекта.
+     * Поля внешней задачи и окончательной очистки добавляются только при необходимости.
+     */
+    private allocateGraphRecord;
+    /**
+     * Материализует signal в графе при первом отслеживаемом чтении
+     * и связывает его с активным потребителем.
+     *
+     * До этого момента signal может хранить значение только в замыкании
+     * и вообще не создавать `ReactiveNode`.
+     */
+    private materializeSignal;
+    /**
+     * Создаёт минимальный handle computed без преждевременного выделения полей графа.
+     * Первый get() материализует запись на этом же объекте и заменяет метод чтения.
+     */
+    private createComputedHandle;
+    /**
+     * Создаёт эффект с одной постоянной задачей внешнего scheduler.
+     * Первый и последующие запуски проходят через задачу; устаревший runner после stop
+     * ничего не выполняет. При синхронной ошибке runner обрабатывает независимую очередь.
+     * @param fn Тело эффекта.
+     * @param onStop Однократная окончательная очистка.
+     */
+    private createScheduledEffect;
+    /**
+     * Регистрирует чтение signal и при необходимости фиксирует pending-значение.
+     * Текущая связь передаётся фиксации, чтобы не уведомлять читающего потребителя повторно.
+     */
+    private readSignalValue;
+    /**
+     * Записывает новое значение или откладывает его фиксацию до чтения в batch.
+     * Сохраняет исходное сравнение через === и учёт автора pending-записи.
+     * Без batch и внешней политики очередь эффектов завершается до возврата из set().
+     */
+    private writeSignalValue;
+    /**
+     * Возвращает кеш либо синхронно актуализирует вычисляемое значение.
+     * Неуспешное вычисление не считается значением. Даже ошибочное чтение сохраняет
+     * связь с активным потребителем, чтобы тот мог восстановиться при изменении источника.
+     */
+    private readComputedValue;
+    /**
+     * Выполняет первый сбор зависимостей и кеширует только успешный результат.
+     * При исключении оставляет состояние повторяемой ошибки, а не чистый undefined.
+     * Уже прочитанные зависимости сохраняются для последующего уведомления.
+     */
+    private evaluateFirstValue;
+    /**
+     * Актуализирует computed: выполняет прямой пересчёт либо проверяет зависимости.
+     * После ошибки getter разрешён повторный пересчёт даже без новой записи источника.
+     */
+    private refreshComputedValue;
+    /**
+     * Фиксирует pending-значение и уведомляет непосредственных потребителей.
+     * Пропускает указанную связь и автора записи, чтобы не дублировать текущую работу.
+     * @returns Изменилось ли зафиксированное значение.
+     */
+    private commitSignalValue;
+    /**
+     * Обрабатывает чтение производителя активным потребителем.
+     * Сначала проверяет текущую и следующую связи; более дорогой поиск вынесен отдельно.
+     */
+    private trackDependency;
+    /**
+     * Согласует чтение с существующим списком зависимостей при несовпадении порядка.
+     * Использует ограниченный линейный поиск, затем поиск среди потребителей производителя.
+     * Существующую связь перемещает или переиспользует; новую создаёт только при необходимости.
+     */
+    private reconcileDependency;
+    /**
+     * Добавляет связь при первоначальном сборе зависимостей.
+     * Предусловие: after является хвостом собранного префикса нового списка.
+     * Связь одновременно включается в список потребителей производителя.
+     */
+    private appendInitialDependency;
+    /**
+     * Вставляет связь после заданного курсора зависимостей потребителя.
+     * Сохраняет ещё не прочитанный хвост списка и увеличивает dependencyCount.
+     */
+    private insertDependency;
+    /**
+     * Переназначает существующую связь другому производителю.
+     * Положение в списке зависимостей потребителя и число его связей сохраняются.
+     */
+    private reuseDepLink;
+    /**
+     * Перемещает существующую зависимость после курсора текущего чтения.
+     * Список потребителей производителя и количество зависимостей не изменяет.
+     */
+    private reorderDependency;
+    /**
+     * Удаляет непрочитанный хвост зависимостей завершившегося запуска.
+     * trackedTail обозначает границу прочитанного префикса, а не неизменный конец списка.
+     * Удаление из списков производителей не выполняет пользовательские callbacks.
+     */
+    private pruneUnreadDependencies;
+    /**
+     * Удаляет связь только из списка потребителей производителя.
+     * Список зависимостей потребителя и его счётчик здесь не изменяются.
+     * Также исправляет курсор поиска, если он указывал на удаляемую связь.
+     */
+    private detachSubLink;
+    /**
+     * Отсоединяет owned-источник сразу с обеих сторон каждой связи.
+     * Вызывается на границе lifetime, а не при обычных чтениях и записях.
+     * Переводит ожидавших проверку потребителей к повторному вычислению при необходимости.
+     */
+    private releaseSourceSubs;
+    /**
+     * Удаляет связь только из списка зависимостей потребителя.
+     * Исправляет курсор прочитанного префикса и dependencyCount; список производителя
+     * должен быть обновлён отдельной операцией.
+     */
+    private detachDependencyLink;
+    /**
+     * Добавляет эффект во внутреннюю очередь один раз до обработки текущей записи.
+     * Флаг SCHEDULED предотвращает повторное добавление без создания task-объекта.
+     */
+    private enqueueEffect;
+    /**
+     * Распространяет invalidation от непосредственных к транзитивным потребителям.
+     * Сохраняет исходный итеративный обход с переиспользуемым стеком; callbacks
+     * не выполняет. Непосредственное и потенциальное изменения отмечает разными флагами.
+     */
+    private propagateInvalidation;
+    /**
+     * Помечает работающего потребителя, только если затронута уже прочитанная связь.
+     * Связи за trackedTail принадлежат прошлому запуску и не означают повторную invalidation.
+     * @returns Новое состояние либо ноль, если уведомление не требуется.
+     */
+    private invalidateReadDependency;
+    /**
+     * Подтверждает необходимость пересчёта непосредственных потребителей.
+     * Применяется после фиксации реально изменившегося значения; позволяет исключить
+     * текущую связь и автора записи.
+     */
+    private confirmSubUpdates;
+    /**
+     * Повторно вычисляет узел, согласует зависимости и сравнивает результат с кешем.
+     * При ошибке восстанавливает контекст, удаляет непрочитанный хвост и оставляет
+     * повторяемое состояние ошибки. Также восстанавливает непосредственного потребителя
+     * skipSub: при разворачивании стека его связь могла быть уже извлечена из буфера.
+     * Неверное значение в кеш не записывается.
+     */
+    private recomputeValue;
+    /**
+     * Восстанавливает связи и состояния после неудачного getter.
+     * Отдельная функция удерживает обработку исключений вне обычной части пересчёта.
+     * Потребитель исключаемой связи мог уже покинуть активный префикс стека.
+     */
+    private restoreComputedFailure;
+    /**
+     * Итеративно проверяет зависимые computed и pending-сигналы перед запуском потребителя.
+     * Использует общий стек с сохранением активного префикса вложенного обхода.
+     * При исключении восстанавливает высоту стека и состояния всех незавершённых
+     * узлов текущего прохода; порядок успешного обхода не меняется.
+     */
+    private refreshDependencies;
+    /**
+     * Выполняет исходный итеративный обход зависимостей без обработки ошибок внутри цикла.
+     * Перед пользовательским вычислением публикует активную высоту стека; оболочка
+     * refreshDependencies() использует этот префикс для восстановления после сбоя.
+     */
+    private walkDependencyChain;
+    /**
+     * Восстанавливает незавершённую запись после прерванной проверки зависимостей.
+     * Computed получает повторяемое состояние ошибки, effect остаётся доступным
+     * для следующей invalidation. Вызывается только на ошибочном пути.
+     */
+    private restoreFailedDependency;
+    /**
+     * Проверяет необходимость запуска, очищает прошлые ресурсы и выполняет тело эффекта.
+     * Ошибка cleanup останавливает эффект до создания ресурсов следующего запуска.
+     * При ошибке тела сохраняет фактически прочитанные зависимости, останавливает
+     * созданных детей и разрешает повторный запуск после следующей записи.
+     * Cleanup, возвращённый после собственного stop, освобождается сразу.
+     */
+    private executeEffect;
+    /**
+     * Завершает неудачный запуск эффекта, не затрагивая успешный путь исполнения.
+     * Сохраняет прочитанные зависимости для следующей invalidation, освобождает
+     * детей неудачного запуска и объединяет ошибки с предыдущими ошибками cleanup.
+     */
+    private failEffectRun;
+    /**
+     * Обрабатывает синхронную очередь до исчерпания, включая добавленную во время прохода работу.
+     * Ошибки отдельных эффектов не блокируют соседей и передаются после обработки.
+     * Путь не проверяет наличие внешней задачи у каждого узла.
+     */
+    private flushSyncEffects;
+    /**
+     * Обрабатывает очередь экземпляра с внешней политикой выполнения.
+     * Обычные внутренние эффекты выполняет сразу, остальные передаёт постоянной задаче.
+     * Ошибка одного элемента не оставляет необработанные записи со старым SCHEDULED.
+     */
+    private flushExternalEffects;
+    /**
+     * Завершает очередь после первой ошибки, собирая последующие причины сбоя.
+     * Вызывается только на ошибочном пути; успешный проход не создаёт массив ошибок
+     * и не устанавливает отдельный catch для каждого элемента.
+     */
+    private drainQueueAfterError;
+    /**
+     * Передаёт эффект его постоянной внешней задаче.
+     * Если schedule() бросает исключение, снимает незавершённую invalidation,
+     * чтобы последующая запись могла снова запросить выполнение.
+     */
+    private requestEffectTask;
+    /**
+     * Окончательно останавливает эффект и освобождает все принадлежащие ему ресурсы.
+     * Сначала делает узел неактивным и отсоединяет связи, затем отменяет задачу,
+     * останавливает детей, выполняет cleanup и onStop. Каждая стадия завершается
+     * несмотря на ошибки соседних стадий; повторный или вложенный stop безопасен.
+     */
+    private disposeEffect;
+    /**
+     * Останавливает все вложенные эффекты в обратном порядке регистрации.
+     * Всегда берёт актуальный хвост: cleanup может удалить другого ребёнка.
+     * Передаёт собранные ошибки только после освобождения всех детей.
+     */
+    private disposeNestedEffects;
+    /**
+     * Задаёт обязательные поля графа перед первым вычислением.
+     * Вызывается только для нематериализованного handle; getter и контекст сохраняются.
+     */
+    private static materializeComputed;
+    /**
+     * Связывает два разных receiver: движок-владелец и читаемый handle.
+     * Эти четыре общие функции адаптируют this; алгоритмы чтения остаются методами
+     * RaphReactivity. Адаптеры создаются один раз на граф, а не на каждое вычисление.
+     */
+    private createHandleReaders;
+    /**
+     * Читает handle без подписки текущего потребителя, сохраняя receiver get().
+     * Прежний контекст восстанавливается и после исключения getter.
+     */
+    private peekHandle;
+    /**
+     * Создаёт единый низкоуровневый read/write accessor для core-дорожки Bench Lab.
+     * Публичный объектный API остаётся отдельным и измеряется в API-tax.
+     * @internal
+     */
+    _signalAccess<T>(initialValue: T): SignalAccess<T>;
+    /**
+     * Создаёт нематериализованный computed для низкоуровневого read API.
+     * Графовые поля появляются при первом чтении; тип описывает обе стадии.
+     * @internal
+     */
+    _computedAccess<T>(fn: () => T): ComputedAccessHandle<T>;
+    /**
+     * Создаёт signal, жизненным циклом которого управляет `ScopeNode`.
+     *
+     * Реактивная логика совпадает с обычным `signal()`, но disposer
+     * дополнительно отсоединяет материализованный источник от графа.
+     *
+     * @internal
+     */
+    _ownedSignal<T>(initialValue: T): OwnedSource<Signal<T>>;
+    /**
+     * Создаёт ленивый computed с финализатором исходящих и входящих связей.
+     * Финализатор работает и до первого вычисления, не материализуя узел ради очистки.
+     * @internal
+     */
+    _ownedComputed<T>(fn: () => T): OwnedSource<ReadonlySignal<T>>;
+    /**
+     * Открывает вложенную синхронную границу группировки.
+     * Внутренний вызывающий код обязан выполнить соответствующий endBatch().
+     * @internal
+     */
+    _startBatch(): void;
+    /**
+     * Закрывает ранее открытую границу и обрабатывает очередь на внешнем уровне.
+     * Предусловие: число закрытий не должно превышать число открытий.
+     * @internal
+     */
+    _endBatch(): void;
+    /**
+     * Проверяет наличие активного потребителя в текущем синхронном стеке чтения.
+     * @internal
+     */
+    _isTracking(): boolean;
+    /**
+     * Показывает, обрабатывает ли экземпляр внутреннюю очередь эффектов.
+     * @internal
+     */
+    _isFlushingEffects(): boolean;
+}
+export declare const signal: RaphReactivity['signal'];
+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'];
+export declare const watch: RaphReactivity['watch'];
+export declare const batch: RaphReactivity['batch'];
+export declare const untracked: RaphReactivity['untracked'];
+export declare const scope: RaphReactivity['scope'];