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

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

@@ -1,9 +1,9 @@
-import { EffectTask, OwnedResource, ReactiveNode, ScopeChildren } from '../../reactivity/types';
-import { RaphScope } from '../ownership/RaphScope';
-import { RaphEffectGroup, RaphEffectInitialMode, RaphFrameContext, RaphPhaseEffect, RaphPhaseTask, RaphWorkCause } from './phase.types';
-import { RaphPhaseState } from './RaphPhasePipeline';
-import { RaphPhaseWatch } from './RaphPhaseWatch';
-export declare const EMPTY_CAUSES: readonly RaphWorkCause[];
+import { EffectTask, OwnedResource, ReactiveNode, ScopeChildren } from '../../reactivity/types.js';
+import { RaphScope } from '../ownership/RaphScope.js';
+import { RaphEffectGroup, RaphEffectInitialMode, RaphFrameContext, RaphPhaseEffect, RaphPhaseTask, RaphWorkCause } from './phase.types.js';
+import { RaphPhaseState } from './RaphPhasePipeline.js';
+import { RaphPhaseWatch } from './RaphPhaseWatch.js';
+export declare const EMPTY_CAUSES: readonly RaphWorkCause<any>[];
 export declare const EMPTY_FRAME: RaphFrameContext;
 export declare const TASK_ACTIVE = 1;
 export declare const TASK_PAUSED: number;
@@ -53,9 +53,9 @@ export declare class RaphPhaseTaskHandle implements RaphPhaseTask {
     readonly _record: RaphPhaseTaskRecord;
     constructor(record: RaphPhaseTaskRecord);
     get phase(): string;
-    get consumerOwner(): RaphScope;
-    get effect(): RaphPhaseEffect;
-    get causes(): readonly RaphWorkCause[];
+    get consumerOwner(): RaphScope<any>;
+    get effect(): RaphPhaseEffect<any>;
+    get causes(): readonly RaphWorkCause<any>[];
     get frame(): RaphFrameContext;
     get priority(): number;
     get sequence(): number;
@@ -90,11 +90,11 @@ export declare class RaphPhaseTaskHandle implements RaphPhaseTask {
  */
 export declare class RaphPhaseTaskDetail {
     static _shapeAnchor: RaphPhaseTaskDetail;
-    extraCauses: Map<object, RaphWorkCause> | undefined;
-    deliveryFirstCause: RaphWorkCause | undefined;
+    extraCauses: Map<object, RaphWorkCause<any>> | undefined;
+    deliveryFirstCause: RaphWorkCause<any> | undefined;
     deliveryFirstCauseKey: object | undefined;
-    deliveryExtraCauses: Map<object, RaphWorkCause> | undefined;
-    deliveryCauses: readonly RaphWorkCause[] | undefined;
+    deliveryExtraCauses: Map<object, RaphWorkCause<any>> | undefined;
+    deliveryCauses: readonly RaphWorkCause<any>[] | undefined;
     deferCount: number;
     constructor();
 }
@@ -122,22 +122,22 @@ export declare class RaphPhaseTaskRecord implements EffectTask, OwnedResource, R
     sequence: number;
     readonly phaseState: RaphPhaseState;
     readonly priority: number;
-    readonly consumerOwner: RaphScope;
-    readonly effect: RaphPhaseEffect;
+    readonly consumerOwner: RaphScope<any>;
+    readonly effect: RaphPhaseEffect<any>;
     node: ReactiveNode | undefined;
     watch: RaphPhaseWatch | undefined;
     group: RaphEffectGroupState | undefined;
     scopeParent: ScopeChildren<OwnedResource> | undefined;
     scopePrevious: OwnedResource | undefined;
     scopeNext: OwnedResource | undefined;
-    firstCause: RaphWorkCause | undefined;
+    firstCause: RaphWorkCause<any> | undefined;
     firstCauseKey: object | undefined;
     frame: RaphFrameContext;
     facade: RaphPhaseTaskHandle | undefined;
     detail: RaphPhaseTaskDetail | undefined;
-    constructor(phaseState: RaphPhaseState, priority: number, consumerOwner: RaphScope, effect: RaphPhaseEffect);
+    constructor(phaseState: RaphPhaseState, priority: number, consumerOwner: RaphScope<any>, effect: RaphPhaseEffect<any>);
     get phase(): string;
-    get dependencyOwner(): RaphScope;
+    get dependencyOwner(): RaphScope<any>;
     get allowScheduleDuringRun(): boolean;
     /**
      * Становится false, когда binding остановлен: так запись видят effect scopes,
@@ -155,7 +155,7 @@ export declare class RaphPhaseTaskRecord implements EffectTask, OwnedResource, R
      * становятся неизменяемыми: WorkGraph создаёт причину без заморозки, а
      * замораживает её первое чтение.
      */
-    get causes(): readonly RaphWorkCause[];
+    get causes(): readonly RaphWorkCause<any>[];
     /**
      * One facade per record: created on first exposure, then reused.
      *
@@ -164,12 +164,12 @@ export declare class RaphPhaseTaskRecord implements EffectTask, OwnedResource, R
      * `process` — и получает её frame; frame каждой следующей доставки
      * записывает её открытие.
      */
-    get task(): RaphPhaseTask;
+    get task(): RaphPhaseTask<any>;
     /** Возвращает редкое состояние записи и создаёт его при первом обращении. */
     detailed(): RaphPhaseTaskDetail;
     notify(token: unknown): void;
     schedule(): void;
-    enqueue(cause: RaphWorkCause, key?: object, schedule?: boolean): void;
+    enqueue(cause: RaphWorkCause<any>, key?: object, schedule?: boolean): void;
     /**
      * Запускает slot группы effects; у записи одиночного effect и watch ничего
      * не делает. Запись группы сама является handle, который возвращает

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

@@ -1,6 +1,6 @@
-import { Disposer } from '../../reactivity/types';
-import { RaphPhaseTaskRecord } from './RaphPhaseTaskRecord';
-import { RuntimeWatch } from '../reactivity/RuntimeWatch';
+import { Disposer } from '../../reactivity/types.js';
+import { RaphPhaseTaskRecord } from './RaphPhaseTaskRecord.js';
+import { RuntimeWatch } from '../reactivity/RuntimeWatch.js';
 /**
  * Callback lifecycle одного explicit watch binding вместе с подпиской, которая
  * его питает. Подписка освобождается при освобождении binding, до cleanup

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

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

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

@@ -1,11 +1,12 @@
-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';
+import { RaphMetaMutationEvent } from '../../path/meta/meta.types.js';
+import { PathEvent } from '../../path/path.types.js';
+import { Disposer, ReadonlySignal } from '../../reactivity/types.js';
+import { RaphNode } from '../ownership/RaphNode.js';
+import { RaphScope } from '../ownership/RaphScope.js';
+import { RaphRuntime } from '../RaphRuntime.js';
+import { RaphRuntimeBase } from '../RaphRuntimeBase.js';
+import { RaphMetaSource } from '../reactivity/RaphMetaSource.js';
+import { RaphAggregate } from '../reactivity/RaphWorkGraph.js';
 export declare const RaphSchedulerType: Readonly<{
     readonly AnimationFrame: "animationFrame";
     readonly Microtask: "microtask";
@@ -24,27 +25,27 @@ export interface RaphFrameContext {
     readonly elapsed: number;
     readonly frame: number;
 }
-export interface RaphStructureCause {
-    readonly node: RaphNode;
-    readonly oldParent?: RaphNode;
-    readonly newParent?: RaphNode;
+export interface RaphStructureCause<Runtime extends RaphRuntimeBase<Runtime> = RaphRuntime> {
+    readonly node: RaphNode<unknown, Runtime>;
+    readonly oldParent?: RaphNode<unknown, Runtime>;
+    readonly newParent?: RaphNode<unknown, Runtime>;
     readonly oldIndex?: number;
     readonly newIndex?: number;
 }
 export type RaphWorkCauseKind = 'producer' | 'structure' | 'path' | 'frame' | 'touch';
 /** Одна logical причина phase delivery. Повторные причины одного source coalesce. */
-export interface RaphWorkCause {
+export interface RaphWorkCause<Runtime extends RaphRuntimeBase<Runtime> = RaphRuntime> {
     readonly kind: RaphWorkCauseKind;
-    readonly source: RaphWatchSource;
-    readonly sourceOwner?: RaphScope;
+    readonly source: RaphWatchSource<Runtime>;
+    readonly sourceOwner?: RaphScope<Runtime>;
     readonly revision: number;
     readonly previous?: unknown;
     readonly value?: unknown;
-    readonly structure?: RaphStructureCause;
+    readonly structure?: RaphStructureCause<Runtime>;
     readonly events?: readonly (PathEvent | RaphMetaMutationEvent)[];
     readonly metadata?: unknown;
 }
-export type RaphPhaseEffect = (task: RaphPhaseTask) => void | Disposer;
+export type RaphPhaseEffect<Runtime extends RaphRuntimeBase<Runtime> = RaphRuntime> = (task: RaphPhaseTask<Runtime>) => void | Disposer;
 /**
  * Тело binding, зарегистрированного через `bindEffect`: task ему не передаётся,
  * поэтому тело объявляется без параметров. Возвращённый cleanup выполняется
@@ -125,26 +126,26 @@ export interface RaphEffectGroup {
  * run/defer/cancel вызываются через task или с явным receiver: извлечённый
  * метод не работает без this.
  */
-export interface RaphPhaseTask {
+export interface RaphPhaseTask<Runtime extends RaphRuntimeBase<Runtime> = RaphRuntime> {
     readonly phase: string;
-    readonly consumerOwner: RaphScope;
-    readonly effect: RaphPhaseEffect;
-    readonly causes: readonly RaphWorkCause[];
+    readonly consumerOwner: RaphScope<Runtime>;
+    readonly effect: RaphPhaseEffect<Runtime>;
+    readonly causes: readonly RaphWorkCause<Runtime>[];
     readonly frame: RaphFrameContext;
     readonly priority: number;
     readonly sequence: number;
-    run: (this: RaphPhaseTask) => void;
-    defer: (this: RaphPhaseTask) => void;
-    cancel: (this: RaphPhaseTask) => void;
+    run: (this: RaphPhaseTask<Runtime>) => void;
+    defer: (this: RaphPhaseTask<Runtime>) => void;
+    cancel: (this: RaphPhaseTask<Runtime>) => void;
 }
-export interface RaphPhaseBatch {
+export interface RaphPhaseBatch<Runtime extends RaphRuntimeBase<Runtime> = RaphRuntime> {
     readonly phase: string;
     readonly frame: RaphFrameContext;
-    readonly tasks: readonly RaphPhaseTask[];
+    readonly tasks: readonly RaphPhaseTask<Runtime>[];
 }
-export interface RaphPhase {
+export interface RaphPhase<Runtime extends RaphRuntimeBase<Runtime> = RaphRuntime> {
     readonly name: string;
-    readonly process?: (batch: RaphPhaseBatch) => void;
+    readonly process?: (batch: RaphPhaseBatch<Runtime>) => void;
 }
 export interface RaphEffectOptions {
     readonly initial?: RaphEffectInitialMode;
@@ -157,15 +158,15 @@ export interface RaphWatchOptions extends Omit<RaphEffectOptions, 'initial'> {
     /** Применяется только к RaphNode source; default — self. */
     readonly include?: RaphWatchInclude;
 }
-export interface RaphNodeWatchSource {
-    readonly source: RaphNode;
+export interface RaphNodeWatchSource<Runtime extends RaphRuntimeBase<Runtime> = RaphRuntime> {
+    readonly source: RaphNode<unknown, Runtime>;
     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;
+export type RaphWatchSource<Runtime extends RaphRuntimeBase<Runtime> = RaphRuntime> = RaphProducerSource | RaphNode<unknown, Runtime> | RaphNodeWatchSource<Runtime> | Runtime | RaphAggregate<Runtime> | RaphMetaSource;
+export type RaphOwnerWatchSource<Runtime extends RaphRuntimeBase<Runtime> = RaphRuntime> = RaphWatchSource<Runtime>;
+export type RaphAggregateSource<Runtime extends RaphRuntimeBase<Runtime> = RaphRuntime> = RaphOwnerWatchSource<Runtime>;
+export interface RaphTaskOrderOptions<Runtime extends RaphRuntimeBase<Runtime> = RaphRuntime> {
+    readonly node: (task: RaphPhaseTask<Runtime>) => RaphNode<unknown, Runtime> | null | undefined;
     readonly direction?: 'parents-first' | 'children-first';
 }

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

@@ -1,8 +1,8 @@
-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';
+import { ParsedDataPath } from '../../path/data-path.types.js';
+import { PathEvents, PathOptions } from '../../path/path.types.js';
+import { RaphKernel } from '../../path/RaphKernel.js';
+import { RaphReactivity } from '../../reactivity/engine.js';
+import { Disposer, OwnedSourceHooks, ReadonlySignal } from '../../reactivity/types.js';
 type PathSignalEngine = Pick<RaphReactivity, '_isTracking' | '_ownedSignal'>;
 /**
  * Реактивный handle одного canonical path в default E2 data-plane.

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

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

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

@@ -1,7 +1,7 @@
-import { OwnedSourceEntry } from '../../reactivity/scope';
-import { RaphScope } from '../ownership/RaphScope';
-import { RuntimeDisposalSweeper, RuntimeSignalWriteTap } from './runtime-reactivity.types';
-import { RuntimeReactivity, RuntimeSignal } from './RuntimeReactivity';
+import { OwnedSourceEntry } from '../../reactivity/scope.js';
+import { RaphScope } from '../ownership/RaphScope.js';
+import { RuntimeDisposalSweeper, RuntimeSignalWriteTap } from './runtime-reactivity.types.js';
+import { RuntimeReactivity, RuntimeSignal } from './RuntimeReactivity.js';
 /**
  * Настройки selector.
  *
@@ -137,7 +137,7 @@ export declare class RuntimeSelector<Key> implements OwnedSourceEntry, RuntimeSi
      * Создаёт selector и подключает его к записям source. Регистрацию у
      * владельца и проверку аргументов выполняет вызывающий код.
      */
-    constructor(owner: RaphScope, reactivity: RuntimeReactivity, source: RuntimeSignal<Key>, equals: ((key: Key, value: Key) => boolean) | undefined);
+    constructor(owner: RaphScope<any>, reactivity: RuntimeReactivity, source: RuntimeSignal<Key>, equals: ((key: Key, value: Key) => boolean) | undefined);
     /**
      * Тег Object.prototype.toString: инструменты, которые обходят только plain
      * objects, принимают selector за неделимое значение и не идут через него в
@@ -153,7 +153,7 @@ export declare class RuntimeSelector<Key> implements OwnedSourceEntry, RuntimeSi
      * Владелец selector как наблюдателя записей source.
      * @internal
      */
-    get _tapOwner(): RaphScope;
+    get _tapOwner(): RaphScope<any>;
     /**
      * Число ключей в индексе triggers: с потребителями и ещё не убранных.
      * @internal
@@ -175,6 +175,8 @@ export declare class RuntimeSelector<Key> implements OwnedSourceEntry, RuntimeSi
      * @internal
      */
     _observesWrites(): boolean;
+    /** @internal См. `inspectSelector`. */
+    _inspect(): RaphSelectorInspection<Key> | undefined;
     /**
      * Будит потребителей ключей, чей ответ изменила запись в source. Вызывается
      * signal-ом после того, как новое значение стало видимым, внутри его границы
@@ -336,3 +338,22 @@ export declare class RuntimeSelector<Key> implements OwnedSourceEntry, RuntimeSi
      */
     private _settleDense;
 }
+/**
+ * Доступ renderer к selector списка: чтение source с подпиской активного
+ * потребителя и ответ ключа без подписки. Список держит одну подписку на source
+ * и сам обновляет строки прежнего и нового ключа вместо подписки каждой строки.
+ * @internal
+ */
+export interface RaphSelectorInspection<Key> {
+    /** Читает source и подписывает активного потребителя на каждую запись в него. */
+    readonly read: () => Key;
+    /** Отвечает, совпадает ли ключ с текущим значением source, без подписки. */
+    readonly test: (key: Key) => boolean;
+}
+/**
+ * Возвращает доступ к selector по его функции либо `undefined`, если значение
+ * не функция selector или selector сравнивает ключи своей `equals`: такая
+ * запись может изменить ответ любого ключа, а не двух.
+ * @internal
+ */
+export declare function inspectSelector<Key>(select: unknown): RaphSelectorInspection<Key> | undefined;

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

@@ -1,10 +1,11 @@
-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;
+import { Disposer, OwnedSourceHooks } from '../../reactivity/types.js';
+import { RaphNode } from '../ownership/RaphNode.js';
+import { RaphScope } from '../ownership/RaphScope.js';
+import { RaphAggregateSource, RaphStructureCause, RaphWatchInclude, RaphWatchSource, RaphWorkCause, RaphWorkCauseKind } from '../phases/phase.types.js';
+import { RaphRuntime } from '../RaphRuntime.js';
+import { RaphRuntimeBase } from '../RaphRuntimeBase.js';
+type WorkSink = (cause: RaphWorkCause<any>, key: object, schedule: boolean) => void;
+type WorkEdgeSource = RaphProducer | RaphNode<unknown, any> | RaphRuntimeBase<any>;
 interface WorkEdge {
     readonly sink: WorkSink;
     readonly kind: 'producer' | 'runtime' | 'self' | 'subtree';
@@ -17,7 +18,7 @@ interface WorkEdgeList {
     first?: WorkEdge;
     last?: WorkEdge;
 }
-type CleanupSource = RaphProducer | RaphNode | RaphAggregate;
+type CleanupSource = RaphProducer | RaphNode<unknown, any> | RaphAggregate<any>;
 interface CleanupEdge {
     cleanup?: () => void;
     source?: CleanupSource;
@@ -29,8 +30,8 @@ interface CleanupEdgeList {
     last?: CleanupEdge;
 }
 interface AggregateSubscription {
-    dispose?: (finalCause?: RaphWorkCause) => void;
-    aggregate?: RaphAggregate;
+    dispose?: (finalCause?: RaphWorkCause<any>) => void;
+    aggregate?: RaphAggregate<any>;
     previous?: AggregateSubscription;
     next?: AggregateSubscription;
 }
@@ -64,16 +65,16 @@ export interface RaphProducerDescription {
  * @internal
  */
 export declare class RaphProducer {
-    readonly owner: RaphScope;
+    readonly owner: RaphScope<any>;
     readonly kind: RaphProducerKind;
     readonly includeRuntime: boolean;
     subscribers: WorkEdgeList | undefined;
     memberships: CleanupEdgeList | undefined;
-    implicitConsumers: Map<RaphNode, number> | undefined;
-    source: RaphWatchSource | undefined;
+    implicitConsumers: Map<RaphNode<unknown, any>, number> | undefined;
+    source: RaphWatchSource<any> | undefined;
     activate: (() => void | Disposer) | undefined;
     runtimeActivation: Disposer | undefined;
-    lastCause: RaphWorkCause | undefined;
+    lastCause: RaphWorkCause<any> | undefined;
     transientNext: RaphProducer | undefined;
     revision: number;
     disposed: boolean;
@@ -84,8 +85,8 @@ export declare class RaphProducer {
      * @internal
      */
     readonly _isProducer: boolean;
-    constructor(owner: RaphScope, kind: RaphProducerKind, includeRuntime: boolean);
-    get runtime(): RaphRuntime;
+    constructor(owner: RaphScope<any>, kind: RaphProducerKind, includeRuntime: boolean);
+    get runtime(): RaphRuntimeBase<any>;
     /**
      * Тег Object.prototype.toString: `[object RaphProducer]`. По нему инструменты,
      * которые копируют и обходят только plain objects, принимают producer за
@@ -103,8 +104,8 @@ export declare class RaphProducer {
     toJSON(): RaphProducerDescription;
 }
 /** Immutable explicit group of granular sources owned by one Runtime scope. */
-export declare class RaphAggregate {
-    readonly owner: RaphScope;
+export declare class RaphAggregate<Runtime extends RaphRuntimeBase<Runtime> = RaphRuntime> {
+    readonly owner: RaphScope<Runtime>;
     private _sources;
     private _disposed;
     private _releaseOwner;
@@ -118,10 +119,10 @@ export declare class RaphAggregate {
     /** @internal */
     private constructor();
     /** @internal */
-    static _create(owner: RaphScope, sources: readonly RaphAggregateSource[]): RaphAggregate;
-    get runtime(): RaphRuntime;
+    static _create<OwnerRuntime extends RaphRuntimeBase<OwnerRuntime>>(owner: RaphScope<OwnerRuntime>, sources: readonly RaphAggregateSource<OwnerRuntime>[]): RaphAggregate<OwnerRuntime>;
+    get runtime(): Runtime;
     get disposed(): boolean;
-    get sources(): readonly RaphAggregateSource[];
+    get sources(): readonly RaphAggregateSource<Runtime>[];
     dispose(): void;
     /** @internal */
     _assertAlive(): void;
@@ -134,13 +135,13 @@ export declare class RaphAggregate {
     /** @internal */
     _disposeOwned(): void;
     /** @internal */
-    _linkSubscription(dispose: (finalCause?: RaphWorkCause) => void): () => void;
+    _linkSubscription(dispose: (finalCause?: RaphWorkCause<any>) => void): () => void;
     /** @internal */
     _linkDependent(edge: CleanupEdge): void;
     /** @internal */
     _detachDependent(edge: CleanupEdge): void;
     /** @internal */
-    _disposalCause(): RaphWorkCause;
+    _disposalCause(): RaphWorkCause<any>;
     /** @internal */
     _detachSubscription(subscription: AggregateSubscription): void;
 }
@@ -152,7 +153,7 @@ export declare class RaphWorkGraph {
      * живой причины.
      * @internal
      */
-    static _valueCauseShapeAnchor: RaphWorkCause;
+    static _valueCauseShapeAnchor: RaphWorkCause<any>;
     private _selfSubscribers;
     private _subtreeSubscribers;
     private _runtimeSubscribers;
@@ -166,8 +167,8 @@ export declare class RaphWorkGraph {
     private _dispatchDepth;
     private _detachedEdges;
     private _disposed;
-    constructor(_runtime: RaphRuntime);
-    createProducer(owner: RaphScope, kind?: RaphProducerKind, options?: ProducerOptions): RaphProducer;
+    constructor(_runtime: RaphRuntimeBase<any>);
+    createProducer(owner: RaphScope<any>, 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;
@@ -179,10 +180,10 @@ export declare class RaphWorkGraph {
      * распознаётся prototype-брендом, а Runtime читается у владельца напрямую:
      * без `instanceof` и без accessor.
      */
-    causeForToken(token: unknown): RaphWorkCause | undefined;
+    causeForToken(token: unknown): RaphWorkCause<any> | 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;
+    notifyProducer(record: RaphProducer, previous?: unknown, value?: unknown, events?: RaphWorkCause<any>['events'], schedule?: boolean, hasReactiveSubscribers?: boolean, includeValues?: boolean): void;
     /**
      * Публикует запись значения producer: форма `notifyProducer()` для причины с
      * `previous` и `value`, без events и с планированием. Так свою запись
@@ -197,7 +198,7 @@ export declare class RaphWorkGraph {
      * @internal
      */
     _notifyValueWrite(record: RaphProducer, previous: unknown, value: unknown, hasReactiveSubscribers: boolean): void;
-    notifyProducerEvents(record: RaphProducer, events: NonNullable<RaphWorkCause['events']>, schedule?: boolean, hasReactiveSubscribers?: boolean): void;
+    notifyProducerEvents(record: RaphProducer, events: NonNullable<RaphWorkCause<any>['events']>, schedule?: boolean, hasReactiveSubscribers?: boolean): void;
     /**
      * Дешёвая предварительная проверка structural publication: `false` означает,
      * что `notifyNode` для этой node вернётся до создания cause и без побочных
@@ -205,7 +206,7 @@ export declare class RaphWorkGraph {
      *
      * @internal
      */
-    _hasStructuralDemand(node: RaphNode): boolean;
+    _hasStructuralDemand(node: RaphNode<unknown, any>): boolean;
     /**
      * Сообщает, есть ли хотя бы один runtime-, subtree- или self-подписчик.
      * `true` означает, что `_hasStructuralDemand` может вернуть `true` для
@@ -214,15 +215,15 @@ export declare class RaphWorkGraph {
      * @internal
      */
     _hasNodeSubscribers(): boolean;
-    notifyNode(node: RaphNode, kind: Extract<RaphWorkCauseKind, 'structure' | 'touch'>, options?: {
+    notifyNode(node: RaphNode<unknown, any>, kind: Extract<RaphWorkCauseKind, 'structure' | 'touch'>, options?: {
         readonly metadata?: unknown;
-        readonly structure?: RaphStructureCause;
-        readonly oldAncestors?: readonly RaphNode[];
-        readonly newAncestors?: readonly RaphNode[];
+        readonly structure?: RaphStructureCause<any>;
+        readonly oldAncestors?: readonly RaphNode<unknown, any>[];
+        readonly newAncestors?: readonly RaphNode<unknown, any>[];
     }): void;
-    createAggregate(owner: RaphScope, sources: readonly RaphAggregateSource[]): RaphAggregate;
-    subscribe(input: RaphWatchSource, include: RaphWatchInclude | undefined, sink: WorkSink): () => void;
-    assertSubscriptionAllowed(consumer: RaphScope, input: RaphWatchSource): void;
+    createAggregate<OwnerRuntime extends RaphRuntimeBase<any>>(owner: RaphScope<OwnerRuntime>, sources: readonly RaphAggregateSource<OwnerRuntime>[]): RaphAggregate<OwnerRuntime>;
+    subscribe(input: RaphWatchSource<any>, include: RaphWatchInclude | undefined, sink: WorkSink): () => void;
+    assertSubscriptionAllowed(consumer: RaphScope<any>, input: RaphWatchSource<any>): void;
     /**
      * Rejects a move that would make an existing implicit reactive edge illegal.
      *
@@ -230,7 +231,7 @@ export declare class RaphWorkGraph {
      * учёта `implicitConsumers`. Рёбра от Runtime signals нигде не учитываются:
      * они читаются из графа в момент проверки.
      */
-    assertReparentAllowed(node: RaphNode, newParent: RaphNode): void;
+    assertReparentAllowed(node: RaphNode<unknown, any>, newParent: RaphNode<unknown, any>): void;
     /**
      * Проверяет живые implicit-рёбра от Runtime signals. Implicit-чтение
      * разрешено только у собственного владельца, его предков и root scope,
@@ -259,7 +260,7 @@ export declare class RaphWorkGraph {
      * в дереве они ни находились.
      */
     private _assertSignalEdgesAllowReparent;
-    releaseNode(node: RaphNode): void;
+    releaseNode(node: RaphNode<unknown, any>): void;
     dispose(): void;
     /**
      * Освобождает producer: публикует финальную structural cause при спросе и

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

@@ -0,0 +1,9 @@
+import { ReactivityEngine } from '../../reactivity/engine-core.js';
+import { ReactiveObjectPolicy } from '../../reactivity/reactive-object.js';
+/** Необязательный адаптер полного профиля без собственного graph или ownership. */
+export interface RuntimeObjectSupport {
+    readonly configure: (engine: ReactivityEngine, policy: ReactiveObjectPolicy) => void;
+    readonly dispose: (engine: ReactivityEngine, policy: ReactiveObjectPolicy) => void;
+    readonly reactive: <T extends object>(engine: ReactivityEngine, value: T) => T;
+}
+export declare const RUNTIME_OBJECT_SUPPORT: RuntimeObjectSupport;