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

package/dist/raph.js

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

package/dist/reactivity/engine.d.ts

@@ -1,4 +1,4 @@
-import { ComputedAccessHandle, Disposer, EffectCallback, EffectFactory, OwnedSource, ReactivityOptions, ReadonlySignal, Signal, SignalAccess, WatchCallback, WatchOptions, WatchSource, WritableComputedOptions } from './types';
+import { ComputedAccessHandle, Disposer, EffectCallback, EffectFactory, OwnedSource, OwnedSourceHooks, ReactivityOptions, ReadonlySignal, Signal, SignalAccess, WatchCallback, WatchOptions, WatchSource, WritableComputedOptions } from './types';
 import { ScopeNode } from './scope';
 export { ScopeNode } from './scope';
 export type { Disposer, EffectCallback, EffectScheduler, EffectTask, ReactivityOptions, ReadonlySignal, Signal, WatchCallback, WatchOptions, WatchSource, WatchValue, WritableComputedOptions, } from './types';
@@ -9,6 +9,7 @@ export type { Disposer, EffectCallback, EffectScheduler, EffectTask, ReactivityO
  * синхронного движка не проверяет внешнюю политику на каждом эффекте.
  */
 export declare class RaphReactivity {
+    private readonly adaptiveDependencyIndex;
     private activeSub;
     private batchDepth;
     private effectReadIndex;
@@ -41,6 +42,11 @@ export declare class RaphReactivity {
      * а peek() выполняет чтение с временно отключённым отслеживанием.
      */
     signal<T>(initialValue: T): Signal<T>;
+    /**
+     * Возвращает стабильный глубокий Proxy для plain object или array.
+     * Object context и per-property sources создаются лениво внутри этого engine.
+     */
+    reactive<T extends object>(value: T): T;
     /**
      * - `(1)` Создаёт ленивое вычисляемое значение только для чтения;
      * - `(2)` Создаёт writable computed, сохраняя исходную функцию setter;
@@ -85,6 +91,8 @@ export declare class RaphReactivity {
      * Поля внешней задачи и окончательной очистки добавляются только при необходимости.
      */
     private allocateGraphRecord;
+    /** Creates a narrow Proxy adapter over the existing intrusive graph. */
+    private createReactivePropertySourceBridge;
     /**
      * Материализует signal в графе при первом отслеживаемом чтении
      * и связывает его с активным потребителем.
@@ -184,6 +192,8 @@ export declare class RaphReactivity {
      * Также исправляет курсор поиска, если он указывал на удаляемую связь.
      */
     private detachSubLink;
+    /** Connects Runtime ownership metadata only for edges whose producer opted in. */
+    private attachDependencyCleanup;
     /**
      * Отсоединяет owned-источник сразу с обеих сторон каждой связи.
      * Вызывается на границе lifetime, а не при обычных чтениях и записях.
@@ -240,6 +250,8 @@ export declare class RaphReactivity {
      * узлов текущего прохода; порядок успешного обхода не меняется.
      */
     private refreshDependencies;
+    /** Settles every direct dependency so a cancelled external delivery can be re-armed. */
+    private settleCancelledDependencies;
     /**
      * Выполняет исходный итеративный обход зависимостей без обработки ошибок внутри цикла.
      * Перед пользовательским вычислением публикует активную высоту стека; оболочка
@@ -290,6 +302,7 @@ export declare class RaphReactivity {
      * чтобы последующая запись могла снова запросить выполнение.
      */
     private requestEffectTask;
+    private scheduleEffectTask;
     /**
      * Окончательно останавливает эффект и освобождает все принадлежащие ему ресурсы.
      * Сначала делает узел неактивным и отсоединяет связи, затем отменяет задачу,
@@ -339,13 +352,13 @@ export declare class RaphReactivity {
      *
      * @internal
      */
-    _ownedSignal<T>(initialValue: T): OwnedSource<Signal<T>>;
+    _ownedSignal<T>(initialValue: T, sourceHooks?: OwnedSourceHooks): OwnedSource<Signal<T>>;
     /**
      * Создаёт ленивый computed с финализатором исходящих и входящих связей.
      * Финализатор работает и до первого вычисления, не материализуя узел ради очистки.
      * @internal
      */
-    _ownedComputed<T>(fn: () => T): OwnedSource<ReadonlySignal<T>>;
+    _ownedComputed<T>(fn: () => T, sourceHooks?: OwnedSourceHooks): OwnedSource<ReadonlySignal<T>>;
     /**
      * Открывает вложенную синхронную границу группировки.
      * Внутренний вызывающий код обязан выполнить соответствующий endBatch().
@@ -370,6 +383,7 @@ export declare class RaphReactivity {
     _isFlushingEffects(): boolean;
 }
 export declare const signal: RaphReactivity['signal'];
+export declare const reactive: RaphReactivity['reactive'];
 export declare function computed<T>(getter: () => T): ReadonlySignal<T>;
 export declare function computed<T>(options: WritableComputedOptions<T>): Signal<T>;
 export declare const effect: RaphReactivity['effect'];

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

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

package/dist/reactivity/types.d.ts

@@ -12,6 +12,11 @@ export interface WritableComputedOptions<T> {
 }
 export type EffectCallback = () => void | Disposer;
 export interface EffectTask {
+    dependencyOwner?: object;
+    allowScheduleDuringRun?: boolean;
+    notify?: (source: unknown) => void;
+    cancelPending?: () => boolean;
+    rearmPending?: () => void;
     schedule: () => void;
     dispose: Disposer;
 }
@@ -19,6 +24,7 @@ export interface EffectScheduler {
     bind: (run: () => void) => EffectTask;
 }
 export interface ReactivityOptions {
+    readonly adaptiveDependencyIndex?: boolean;
     readonly effectScheduler?: EffectScheduler;
 }
 export type WatchSource<T = unknown> = ReadonlySignal<T> | (() => T);
@@ -76,6 +82,7 @@ export interface ReactiveEdge {
     nextSub: ReactiveEdge | null;
     prevDep: ReactiveEdge | null;
     nextDep: ReactiveEdge | null;
+    dependencyCleanup?: Disposer;
 }
 /**
  * Материализованная запись графа: signal, computed либо effect.
@@ -91,12 +98,16 @@ export interface ReactiveNode<T = any> extends ScopeChildren<ReactiveNode>, Scop
     tailDep: ReactiveEdge | null;
     depCount: number;
     subSearchCursor?: ReactiveEdge;
+    dependencyIndex?: Map<ReactiveNode, ReactiveEdge>;
+    dependencyLookupDebt?: number;
+    dependencyLookupSearches?: number;
     evaluate: (() => any) | undefined;
     cachedValue: T;
     pendingValue?: T;
     pendingAuthor?: ReactiveNode | null;
     effectTask?: EffectTask;
     onStop?: Disposer;
+    sourceHooks?: OwnedSourceHooks;
 }
 /**
  * Низкоуровневые read/write для raw-дорожки Bench Lab.
@@ -136,8 +147,22 @@ export interface ComputedSourceAccessHandle<T> extends Partial<ReactiveNode<T>>,
  */
 export interface OwnedSource<T> {
     source: T;
+    hasSubscribers?: () => boolean;
     dispose: SourceFinalizer;
 }
+/**
+ * Необязательные Runtime hooks owned-источника. Standalone sources не передают
+ * этот объект и сохраняют прежний hot path без ownership metadata.
+ * @internal
+ */
+export interface OwnedSourceHooks {
+    readonly token?: unknown;
+    readonly dependencyOwner?: object;
+    readonly onDependency?: (consumerOwner: object) => Disposer | undefined;
+    readonly onChange?: (previous: unknown, value: unknown, hasReactiveSubscribers: boolean) => void;
+    readonly onInvalidate?: (hasReactiveSubscribers: boolean) => void;
+    readonly onDispose?: (hasReactiveSubscribers: boolean) => void;
+}
 /**
  * Общие для одного графа адаптеры receiver его handles.
  * Не хранят состояние алгоритмов: передают исходный handle методам движка.

package/dist/reactivity.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("./debug/reactivity/scope.cjs");require("./debug/reactivity/watch.cjs");const e=require("./debug/reactivity/engine.cjs");exports.ScopeNode=t.ScopeNode;exports.RaphReactivity=e.RaphReactivity;exports.batch=e.batch;exports.computed=e.computed;exports.effect=e.effect;exports.scope=e.scope;exports.signal=e.signal;exports.untracked=e.untracked;exports.watch=e.watch;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./debug/reactivity/engine.cjs"),t=require("./debug/reactivity/scope.cjs");exports.RaphReactivity=e.RaphReactivity;exports.batch=e.batch;exports.computed=e.computed;exports.effect=e.effect;exports.reactive=e.reactive;exports.scope=e.scope;exports.signal=e.signal;exports.untracked=e.untracked;exports.watch=e.watch;exports.ScopeNode=t.ScopeNode;

package/dist/reactivity.js

@@ -1,14 +1,14 @@
-import { ScopeNode as c } from "./debug/reactivity/scope.js";
-import "./debug/reactivity/watch.js";
-import { RaphReactivity as a, batch as r, computed as f, effect as i, scope as m, signal as d, untracked as h, watch as n } from "./debug/reactivity/engine.js";
+import { RaphReactivity as c, batch as o, computed as a, effect as p, reactive as r, scope as f, signal as i, untracked as d, watch as h } from "./debug/reactivity/engine.js";
+import { ScopeNode as n } from "./debug/reactivity/scope.js";
 export {
-  a as RaphReactivity,
-  c as ScopeNode,
-  r as batch,
-  f as computed,
-  i as effect,
-  m as scope,
-  d as signal,
-  h as untracked,
-  n as watch
+  c as RaphReactivity,
+  n as ScopeNode,
+  o as batch,
+  a as computed,
+  p as effect,
+  r as reactive,
+  f as scope,
+  i as signal,
+  d as untracked,
+  h as watch
 };