@raphy-js/raph 1.0.0-dev.18

package/dist/runtime/errors.d.ts

@@ -0,0 +1,21 @@
+import { RaphError } from '../api/errors';
+/**
+ * Сообщает о записи вне action при включённом enforceActions.
+ */
+export declare class RaphActionError extends RaphError {
+}
+/**
+ * Сообщает об обращении к уже освобождённому runtime-owner.
+ */
+export declare class RaphDisposedError extends RaphError {
+}
+/**
+ * Сообщает о попытке связать owners из разных runtimes.
+ */
+export declare class RaphCrossRuntimeError extends RaphError {
+}
+/**
+ * Сообщает об ошибке пользовательского phase processor или task resolution.
+ */
+export declare class RaphPhaseProcessError extends RaphError {
+}

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/ownership/parent-graph.types.d.ts

@@ -0,0 +1,4 @@
+import { RaphNode } from './RaphNode';
+export interface DepGraph<T extends RaphNode = RaphNode> {
+    parentsOf: (node: T) => ReadonlySet<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/ownership/throwDisposalErrors.d.ts

@@ -0,0 +1 @@
+export declare function throwDisposalErrors(errors: unknown[], message?: string): void;

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

@@ -0,0 +1,51 @@
+import { FrameLoopLease } from './phase.types';
+/**
+ * Ленивые frame callbacks не запускаются обычной реактивной работой.
+ */
+export declare class RaphFrameLoop {
+    private readonly _tick;
+    private readonly _leases;
+    private _frameHandle;
+    private _frameHandleKind;
+    private _scheduleToken;
+    private _running;
+    private _manual;
+    /**
+     * Создаёт frame-loop, который запрашивает выполнение runtime pipeline.
+     */
+    constructor(_tick: () => void);
+    /**
+     * Показывает, выполняется ли автоматический frame-loop.
+     */
+    get running(): boolean;
+    /**
+     * Получает lease, удерживающий автоматический frame-loop активным.
+     */
+    acquire(owner: string): FrameLoopLease;
+    /**
+     * Запускает manual lease frame-loop.
+     */
+    start(): void;
+    /**
+     * Останавливает manual lease, не затрагивая внешние leases.
+     */
+    stop(): void;
+    /**
+     * Снимает все leases и отменяет запланированный frame callback.
+     */
+    dispose(): void;
+    /**
+     * Возвращает внутреннее состояние frame-loop для диагностики.
+     * @internal
+     */
+    _debugState(): {
+        running: boolean;
+        manual: boolean;
+        leases: number;
+    };
+    private _onFrame;
+    private _ensureRunning;
+    private _schedule;
+    private _reconcile;
+    private _stop;
+}

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/reactivity/PathHandle.d.ts

@@ -0,0 +1,80 @@
+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.
+ */
+export declare class PathHandle<T> implements ReadonlySignal<T | undefined> {
+    readonly path: string;
+    readonly options: PathOptions;
+    private _revision;
+    private _disposeRevision;
+    private _isTracking;
+    private _store;
+    private _release;
+    private readonly _masks;
+    private _assertOwnerAlive;
+    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, sourceHooks?: OwnedSourceHooks, notifyEvents?: (events: PathEvents, hasReactiveSubscribers: boolean) => void);
+    /**
+     * Показывает, освобождён ли path handle.
+     */
+    get disposed(): boolean;
+    /**
+     * Читает path с регистрацией реактивной зависимости.
+     */
+    get(): T | undefined;
+    /**
+     * Читает path без регистрации реактивной зависимости.
+     */
+    peek(): T | undefined;
+    /**
+     * Записывает значение path через runtime write policy.
+     */
+    set(value: T): void;
+    /**
+     * Объединяет значение path через runtime write policy.
+     */
+    merge(value: Partial<T>): void;
+    /**
+     * Удаляет значение path через runtime write policy.
+     */
+    delete(): void;
+    /**
+     * Проверяет наличие значения path.
+     */
+    has(): boolean;
+    /**
+     * Отсоединяет 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;
+}
+export {};

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 {};