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

package/dist/runtime/ownership/RaphEffectScope.d.ts

@@ -0,0 +1,29 @@
+import { Disposer } from '../../reactivity/types';
+import { RaphEffectOptions, RaphOwnerWatchSource, RaphPhaseEffect, RaphWatchOptions } from '../phases/phase.types';
+import { RaphScope } from './RaphScope';
+/** Pauses phase deliveries without detaching dependencies or losing accumulated causes. */
+export declare class RaphEffectScope {
+    private readonly _owner;
+    private _registrations;
+    private _children;
+    private _selfPaused;
+    private _ancestorPauses;
+    private _disposed;
+    private readonly _releaseOwner;
+    private readonly _parent;
+    constructor(_owner: RaphScope, parent?: RaphEffectScope | null);
+    get paused(): boolean;
+    get disposed(): boolean;
+    fork(owner: RaphScope): RaphEffectScope;
+    effect(phase: string, callback: RaphPhaseEffect, options?: RaphEffectOptions): Disposer;
+    watch(source: RaphOwnerWatchSource, phase: string, callback: RaphPhaseEffect, options?: RaphWatchOptions): Disposer;
+    pause(): void;
+    resume(): void;
+    private _pause;
+    private _resume;
+    dispose(): void;
+    private _add;
+    private _assertAlive;
+    private _addChild;
+    private _changeAncestorPause;
+}

package/dist/runtime/ownership/RaphNode.d.ts

@@ -0,0 +1,40 @@
+import { RaphRuntime } from '../RaphRuntime';
+import { RaphScope } from './RaphScope';
+export interface NodeOptions {
+    readonly id?: string;
+    readonly priority?: number;
+    readonly parent?: RaphNode;
+    readonly meta?: Readonly<Record<string, unknown>>;
+    readonly type?: string;
+}
+/** Scope with an explicit parent/children ownership position. */
+export declare class RaphNode<TApi = unknown> extends RaphScope {
+    priority: number;
+    private _parent;
+    private readonly _children;
+    private _published;
+    readonly api: Readonly<TApi>;
+    meta: Record<string, unknown>;
+    type: string;
+    /** Distinguishes a subtree granule from the node's self granule. @internal */
+    readonly _subtreeSourceIdentity: Readonly<{}>;
+    constructor(parent: RaphNode | RaphRuntime | null, options?: Omit<NodeOptions, 'parent'>, runtime?: RaphRuntime, publication?: never);
+    get node(): RaphNode<TApi>;
+    get parent(): RaphNode | null;
+    get children(): readonly RaphNode[];
+    addChild(node: RaphNode): boolean;
+    reorderChildren(nodes: readonly RaphNode[]): void;
+    options(options: Pick<NodeOptions, 'meta' | 'priority' | 'type'>): void;
+    /** Invalidates coarse self/subtree/runtime granules for non-reactive state. */
+    touch(metadata?: unknown): void;
+    remove(): void;
+    dispose(): void;
+    /** @internal */
+    _setApi(api: TApi): void;
+    /** Publishes a fully initialized provisional subtree. @internal */
+    _publishCreation(): void;
+    /** @internal */
+    _isPublished(): boolean;
+}
+/** Creates an unpublished node that Runtime.node() commits after setup. @internal */
+export declare function createProvisionalNode<TApi>(parent: RaphNode, options: Omit<NodeOptions, 'parent'>, runtime: RaphRuntime): RaphNode<TApi>;

package/dist/runtime/ownership/RaphScope.d.ts

@@ -0,0 +1,38 @@
+import { Disposer, OwnedSource, ReadonlySignal, Signal, WritableComputedOptions } from '../../reactivity/types';
+import { RaphAggregateSource, RaphEffectOptions, RaphPhaseEffect, RaphWatchOptions, RaphWatchSource } from '../phases/phase.types';
+import { RaphRuntime } from '../RaphRuntime';
+import { RaphAggregate } from '../reactivity/RaphWorkGraph';
+import { RaphNode } from './RaphNode';
+/** Runtime owner storage intentionally does not inherit standalone unphased effect/watch. */
+export declare class RaphScope {
+    readonly id: string;
+    readonly runtime: RaphRuntime;
+    private readonly _resources;
+    protected _disposed: boolean;
+    protected _disposing: boolean;
+    constructor(id: string, runtime: RaphRuntime);
+    get disposed(): boolean;
+    get active(): boolean;
+    /** Stable selector for process ordering; plain scopes are not tree nodes. */
+    get node(): RaphNode | undefined;
+    signal<T>(value: T): Signal<T>;
+    computed<T>(getter: () => T): ReadonlySignal<T>;
+    computed<T>(options: WritableComputedOptions<T>): Signal<T>;
+    effect(phase: string, callback: RaphPhaseEffect, options?: RaphEffectOptions): Disposer;
+    watch(source: RaphWatchSource, phase: string, callback: RaphPhaseEffect, options?: RaphWatchOptions): Disposer;
+    aggregate(sources: readonly RaphAggregateSource[]): RaphAggregate;
+    action<Args extends unknown[], Result>(operation: (...args: Args) => Result): (...args: Args) => Result;
+    action<Args extends unknown[], Result>(name: string, operation: (...args: Args) => Result): (...args: Args) => Result;
+    own(disposer: Disposer): Disposer;
+    dispose(): void;
+    /** @internal */
+    _adoptResource(disposer: Disposer): Disposer;
+    /** @internal */
+    _adoptSource<T>(source: OwnedSource<T>): T;
+    /** @internal */
+    _debugResourceCount(): number;
+    /** @internal */
+    _debugSourceCount(): number;
+    /** @internal */
+    _assertAlive(): void;
+}

package/dist/runtime/{parent-graph.d.ts → ownership/parent-graph.types.d.ts}

@@ -2,4 +2,3 @@ import { RaphNode } from './RaphNode';
 export interface DepGraph<T extends RaphNode = RaphNode> {
     parentsOf: (node: T) => ReadonlySet<T>;
 }
-export declare function parentGraph<T extends RaphNode>(): DepGraph<T>;

package/dist/runtime/ownership/parentGraph.d.ts

@@ -0,0 +1,3 @@
+import { DepGraph } from './parent-graph.types';
+import { RaphNode } from './RaphNode';
+export declare function parentGraph<T extends RaphNode>(): DepGraph<T>;

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

@@ -0,0 +1,79 @@
+import { Disposer, EffectTask } from '../../reactivity/types';
+import { RaphScope } from '../ownership/RaphScope';
+import { RaphFrameContext, RaphPhase, RaphPhaseEffect, RaphPhaseTask, RaphSchedulerMode, RaphWorkCause } from './phase.types';
+export interface RaphPhaseBinding extends EffectTask {
+    readonly task: RaphPhaseTask;
+    /** Stops the owning implicit effect when a fatal discard cannot re-arm it. @internal */
+    abort?: Disposer;
+    enqueue: (cause: RaphWorkCause, key?: object, schedule?: boolean) => void;
+    pause: () => void;
+    resume: () => void;
+}
+/** Единая Runtime-owned очередь persistent phase bindings. */
+export declare class RaphPhasePipeline {
+    private readonly _scheduler;
+    private readonly _runUntracked;
+    private readonly _resolveCause;
+    private readonly _deferSync;
+    private readonly _tracePhase?;
+    private _phases;
+    private _phaseByName;
+    private readonly _phaseBindings;
+    private readonly _queues;
+    private readonly _deferred;
+    private readonly _idleWaiters;
+    private _taskSequence;
+    private _scheduled;
+    private _scheduleToken;
+    private _frameHandle;
+    private _frameHandleKind;
+    private _configurationLocked;
+    private _running;
+    private _disposed;
+    private _firstFrameAt;
+    private _lastFrameAt;
+    private _frameNumber;
+    private _frame;
+    constructor(_scheduler: RaphSchedulerMode, _runUntracked: <T>(operation: () => T) => T, _resolveCause: (token: unknown) => RaphWorkCause | undefined, _deferSync?: () => boolean, _tracePhase?: ((phase: string, status: "end" | "error" | "start", error?: unknown) => void) | undefined);
+    get frame(): RaphFrameContext;
+    get phases(): readonly RaphPhase[];
+    definePhases(phases: readonly RaphPhase[]): void;
+    addPhase(phase: RaphPhase): void;
+    clearPhases(): void;
+    requirePhase(name: string): void;
+    bindTask(phaseInput: string, consumerOwner: RaphScope, effect: RaphPhaseEffect, priority: number, runner: () => void): RaphPhaseBinding;
+    request(): void;
+    afterFlush(): Promise<void>;
+    flush(): void;
+    dispose(): void;
+    _debugPending(): boolean;
+    private _describeQueued;
+    private _createTask;
+    private _beginDelivery;
+    private _runDelivery;
+    private _deferDelivery;
+    private _cancelDelivery;
+    private _finishDelivery;
+    private _appendCause;
+    private _queue;
+    private _disposeTask;
+    private _pauseTask;
+    private _resumeTask;
+    private _restoreDeliveryCausesBeforePending;
+    private _takePhase;
+    private _schedule;
+    private _scheduleDeferredTurn;
+    private _cancelScheduled;
+    private _activateDeferred;
+    private _nextFrame;
+    private _assertRetainedPhases;
+    private _assertDelivery;
+    private _hasQueued;
+    private _hasPending;
+    private _cancelAllQueued;
+    private _cancelAllDeferred;
+    private _acknowledgeDiscard;
+    private _clearPendingDelivery;
+    private _settleIdleWaiters;
+    private _assertAlive;
+}

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

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

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

@@ -0,0 +1,92 @@
+import { RaphMetaMutationEvent } from '../../path/meta/meta.types';
+import { PathEvent } from '../../path/path.types';
+import { Disposer, ReadonlySignal } from '../../reactivity/types';
+import { RaphNode } from '../ownership/RaphNode';
+import { RaphScope } from '../ownership/RaphScope';
+import { RaphRuntime } from '../RaphRuntime';
+import { RaphMetaSource } from '../reactivity/RaphMetaSource';
+import { RaphAggregate } from '../reactivity/RaphWorkGraph';
+export declare const RaphSchedulerType: Readonly<{
+    readonly AnimationFrame: "animationFrame";
+    readonly Microtask: "microtask";
+    readonly Sync: "sync";
+}>;
+export type RaphSchedulerMode = typeof RaphSchedulerType[keyof typeof RaphSchedulerType];
+export type RaphEffectInitialMode = 'scheduled' | 'sync';
+export type RaphWatchInitialMode = RaphEffectInitialMode | 'none';
+export interface FrameLoopLease {
+    readonly owner: string;
+    release: () => void;
+}
+export interface RaphFrameContext {
+    readonly now: number;
+    readonly delta: number;
+    readonly elapsed: number;
+    readonly frame: number;
+}
+export interface RaphStructureCause {
+    readonly node: RaphNode;
+    readonly oldParent?: RaphNode;
+    readonly newParent?: RaphNode;
+    readonly oldIndex?: number;
+    readonly newIndex?: number;
+}
+export type RaphWorkCauseKind = 'producer' | 'structure' | 'path' | 'frame' | 'touch';
+/** Одна logical причина phase delivery. Повторные причины одного source coalesce. */
+export interface RaphWorkCause {
+    readonly kind: RaphWorkCauseKind;
+    readonly source: RaphWatchSource;
+    readonly sourceOwner?: RaphScope;
+    readonly revision: number;
+    readonly previous?: unknown;
+    readonly value?: unknown;
+    readonly structure?: RaphStructureCause;
+    readonly events?: readonly (PathEvent | RaphMetaMutationEvent)[];
+    readonly metadata?: unknown;
+}
+export type RaphPhaseEffect = (task: RaphPhaseTask) => void | Disposer;
+/** Persistent task identity, передаваемая phase process и effect callback. */
+export interface RaphPhaseTask {
+    readonly phase: string;
+    readonly consumerOwner: RaphScope;
+    readonly effect: RaphPhaseEffect;
+    readonly causes: readonly RaphWorkCause[];
+    readonly frame: RaphFrameContext;
+    readonly priority: number;
+    readonly sequence: number;
+    run: () => void;
+    defer: () => void;
+    cancel: () => void;
+}
+export interface RaphPhaseBatch {
+    readonly phase: string;
+    readonly frame: RaphFrameContext;
+    readonly tasks: readonly RaphPhaseTask[];
+}
+export interface RaphPhase {
+    readonly name: string;
+    readonly process?: (batch: RaphPhaseBatch) => void;
+}
+export interface RaphEffectOptions {
+    readonly initial?: RaphEffectInitialMode;
+    readonly priority?: number;
+}
+export type RaphWatchInclude = 'self' | 'subtree';
+export interface RaphWatchOptions extends Omit<RaphEffectOptions, 'initial'> {
+    /** `none` creates a change-only binding without an initial delivery. */
+    readonly initial?: RaphWatchInitialMode;
+    /** Применяется только к RaphNode source; default — self. */
+    readonly include?: RaphWatchInclude;
+}
+export interface RaphNodeWatchSource {
+    readonly source: RaphNode;
+    readonly include: RaphWatchInclude;
+}
+export type RaphProducerSource = ReadonlySignal<unknown>;
+export type RaphWatchSource = RaphProducerSource | RaphNode | RaphNodeWatchSource | RaphRuntime | RaphAggregate | RaphMetaSource;
+export type RaphOwnerWatchSource = RaphWatchSource;
+export type RaphAggregateSource = RaphOwnerWatchSource;
+export interface RaphTaskOrderOptions {
+    readonly node: (task: RaphPhaseTask) => RaphNode | null | undefined;
+    readonly direction?: 'parents-first' | 'children-first';
+}

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

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

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

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

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

@@ -0,0 +1,171 @@
+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 = RaphProducerRecord | 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 = RaphProducerRecord | 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;
+}
+declare const PRODUCER_RECORD: unique symbol;
+/** @internal */
+export interface RaphProducerRecord {
+    readonly [PRODUCER_RECORD]: true;
+    readonly runtime: RaphRuntime;
+    readonly owner: RaphScope;
+    readonly kind: Extract<RaphWorkCauseKind, 'frame' | 'path' | 'producer'>;
+    readonly includeRuntime: boolean;
+    subscribers?: WorkEdgeList;
+    memberships?: CleanupEdgeList;
+    implicitConsumers?: Map<RaphNode, number>;
+    alias?: object;
+    source?: RaphWatchSource;
+    activate?: () => void | Disposer;
+    runtimeActivation?: Disposer;
+    lastCause?: RaphWorkCause;
+    transientNext?: RaphProducerRecord;
+    revision: number;
+    disposed: boolean;
+}
+/** 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;
+    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?: RaphProducerRecord['kind'], options?: ProducerOptions): RaphProducerRecord;
+    attachProducer<T extends object>(record: RaphProducerRecord, source: T): T;
+    setProducerActivation(record: RaphProducerRecord, activate: () => void | Disposer, activateForRuntime?: boolean): void;
+    producerHooks(record: RaphProducerRecord): OwnedSourceHooks;
+    causeForToken(token: unknown): RaphWorkCause | undefined;
+    /** Clears mutation-local payloads after engine propagation consumed them. */
+    clearTransientCauses(): void;
+    notifyProducer(record: RaphProducerRecord, previous?: unknown, value?: unknown, events?: RaphWorkCause['events'], schedule?: boolean, hasReactiveSubscribers?: boolean, includeValues?: boolean): void;
+    notifyProducerEvents(record: RaphProducerRecord, events: NonNullable<RaphWorkCause['events']>, schedule?: boolean, hasReactiveSubscribers?: boolean): void;
+    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. */
+    assertReparentAllowed(node: RaphNode, newParent: RaphNode): void;
+    releaseNode(node: RaphNode): void;
+    dispose(): void;
+    private _disposeProducer;
+    private _dispatchProducer;
+    private _dispatchProducerLazily;
+    private _createProducerCause;
+    private _retainRuntimeSubscriber;
+    private _releaseRuntimeSubscriber;
+    private _releaseRuntimeActivations;
+    private _linkImplicitDependency;
+    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/{RuntimeReactivity.d.ts → reactivity/RuntimeReactivity.d.ts}

@@ -1,8 +1,7 @@
-import { ScopeNode } from '../reactivity/scope';
-import { ReadonlySignal, Signal } from '../reactivity/types';
-import { RaphEffectInitialMode } from './phase.types';
+import { OwnedSourceHooks, ReactivityOptions, ReadonlySignal, Signal } from '../../reactivity/types';
+import { RaphScope } from '../ownership/RaphScope';
 import { RuntimeEffectBinding, RuntimeSignalLifecycle } from './runtime-reactivity.types';
-import { RaphReactivity } from '../reactivity/engine';
+import { RaphReactivity } from '../../reactivity/engine';
 /**
  * Внутренний policy adapter, наследующий реактивные алгоритмы без дублирования.
  */
@@ -12,11 +11,11 @@ export declare class RuntimeReactivity extends RaphReactivity {
     /**
      * Создаёт policy adapter реактивного графа для одного runtime.
      */
-    constructor(_lifecycle: RuntimeSignalLifecycle);
+    constructor(_lifecycle: RuntimeSignalLifecycle, options?: Pick<ReactivityOptions, 'adaptiveDependencyIndex'>);
     /**
      * Создаёт временную registration boundary для runtime effect.
      */
-    withEffectBinding<T>(binding: RuntimeEffectBinding | undefined, initial: RaphEffectInitialMode, operation: () => T): T;
+    withEffectBinding<T>(binding: RuntimeEffectBinding | undefined, operation: () => T): T;
     /**
      * Выполняет untracked-операцию, сохраняя runtime owner context.
      */
@@ -25,16 +24,22 @@ export declare class RuntimeReactivity extends RaphReactivity {
      * Возвращает 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, operation: () => T): T;
+    runWithOwner<T>(lifecycle: RuntimeSignalLifecycle | undefined, consumerOwner: RaphScope | undefined, operation: () => T): T;
     /**
      * Создаёт owned signal с runtime lifecycle policy.
      */
-    signalForOwner<T>(initialValue: T, owner?: ScopeNode): Signal<T>;
+    signalForOwner<T>(initialValue: T, owner: RaphScope, sourceHooks?: OwnedSourceHooks, captureWriteInBoundary?: (write: (value: T) => void) => void): Signal<T>;
     /**
      * Создаёт owned computed с runtime lifecycle policy.
      */
-    computedForOwner<T>(getter: () => T, owner?: ScopeNode): ReadonlySignal<T>;
+    computedForOwner<T>(getter: () => T, owner: RaphScope, sourceHooks?: OwnedSourceHooks): ReadonlySignal<T>;
 }

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

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

package/dist/runtime/{runtime-reactivity.types.d.ts → reactivity/runtime-reactivity.types.d.ts}

@@ -1,8 +1,10 @@
-import { EffectTask } from '../reactivity/types';
+import { EffectTask } from '../../reactivity/types';
+import { RaphScope } from '../ownership/RaphScope';
 export interface RuntimeSignalLifecycle {
     owner: object | undefined;
     assertWriteAllowed?: () => void;
     runWrite?: <T>(operation: () => T) => T;
+    assertDependencyAllowed: (sourceOwner: RaphScope, consumerOwner: RaphScope) => void;
     throwDisposed: () => never;
     throwCrossRuntime: (owner: object) => never;
 }

package/dist/runtime.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./debug/runtime/errors.cjs"),r=require("./debug/runtime/parent-graph.cjs"),t=require("./debug/runtime/PathHandle.cjs"),p=require("./debug/runtime/phase.types.cjs"),a=require("./debug/runtime/RaphNode.cjs"),u=require("./debug/runtime/RaphRuntime.cjs"),o=require("./debug/runtime/RaphScope.cjs");exports.RaphActionError=e.RaphActionError;exports.RaphCrossRuntimeError=e.RaphCrossRuntimeError;exports.RaphDisposedError=e.RaphDisposedError;exports.parentGraph=r.parentGraph;exports.PathHandle=t.PathHandle;exports.RaphSchedulerType=p.RaphSchedulerType;exports.RaphNode=a.RaphNode;exports.RaphRuntime=u.RaphRuntime;exports.RaphScope=o.RaphScope;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./debug/runtime/errors.cjs"),r=require("./debug/runtime/ownership/parentGraph.cjs"),a=require("./debug/runtime/ownership/RaphEffectScope.cjs"),p=require("./debug/runtime/ownership/RaphNode.cjs"),o=require("./debug/runtime/ownership/RaphScope.cjs"),s=require("./debug/runtime/phases/orderPhaseTasks.cjs"),t=require("./debug/runtime/phases/phase.types.cjs"),h=require("./debug/runtime/RaphRuntime.cjs"),n=require("./debug/runtime/reactivity/PathHandle.cjs");exports.RaphActionError=e.RaphActionError;exports.RaphCrossRuntimeError=e.RaphCrossRuntimeError;exports.RaphDisposedError=e.RaphDisposedError;exports.RaphPhaseProcessError=e.RaphPhaseProcessError;exports.parentGraph=r.parentGraph;exports.RaphEffectScope=a.RaphEffectScope;exports.RaphNode=p.RaphNode;exports.RaphScope=o.RaphScope;exports.orderPhaseTasks=s.orderPhaseTasks;exports.RaphSchedulerType=t.RaphSchedulerType;exports.RaphRuntime=h.RaphRuntime;exports.PathHandle=n.PathHandle;