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

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

@@ -1,3 +1,4 @@
+import { OwnedSourceHooks } from './types.js';
 /**
  * Opaque per-property producer used by the reactive-object adapter.
  * The concrete record belongs to RaphReactivity's existing intrusive graph.
@@ -11,19 +12,74 @@ export type ReactivePropertySource = object;
  */
 export interface ReactivePropertySourceBridge {
     readonly batch: <T>(operation: () => T) => T;
-    readonly create: () => ReactivePropertySource;
+    readonly startBatch: () => void;
+    readonly endBatch: () => void;
+    readonly create: (hooks?: OwnedSourceHooks) => ReactivePropertySource;
+    readonly createTransient: (onUnobserved: () => void) => ReactivePropertySource;
     readonly isTracking: () => boolean;
     readonly track: (source: ReactivePropertySource) => void;
     readonly trigger: (source: ReactivePropertySource) => void;
+    readonly hasMultipleSubscribers: (source: ReactivePropertySource) => boolean;
+    readonly release: (source: ReactivePropertySource) => void;
+}
+export interface ReactiveObjectExtension {
+    readValue: (value: unknown, deep: boolean) => unknown;
+}
+export interface ReactiveObjectSupport {
+    readonly bridge: ReactivePropertySourceBridge;
+    readonly policy: ReactiveObjectPolicy;
+    wrap: (raw: object, extension: ReactiveObjectExtension, deep: boolean) => object;
+    claim: (raw: object) => void;
+    unwrap: (value: unknown) => unknown;
+    identity: (raw: object) => ReactiveObjectIdentity;
+    hasView: (raw: object) => boolean;
+    /** Plain view слоя observable для raw этого context. */
+    observedView: (raw: object) => {
+        readonly view: object;
+        readonly deep: boolean;
+    } | undefined;
+    setObservedView: (raw: object, view: object, deep: boolean) => void;
+    write: <T>(operation: () => T) => T;
+    /**
+     * Closure-free форма write(): WRITE_NESTED — выполнить операцию сразу,
+     * WRITE_CALLBACK — передать её в write(), WRITE_OPENED — выполнить и затем
+     * вызвать closeWrite() либо throw failWrite(error).
+     */
+    openWrite: () => WriteMode;
+    closeWrite: () => void;
+    failWrite: (error: unknown) => unknown;
+    /** Validates write permissions; true lets a caller reuse an already open batch. */
+    tryDirectWrite: () => boolean;
 }
 /** Runtime policy installed for one RuntimeReactivity instance. @internal */
 export interface ReactiveObjectPolicy {
     readonly owner?: object;
-    readonly assertRead?: () => void;
+    readonly assertRead?: (() => void) | undefined;
     readonly assertWrite?: () => void;
     readonly runWrite?: <T>(operation: () => T) => T;
+    readonly writeBoundary?: {
+        _isWriteBatchOpen: () => boolean;
+        _enterWrite: () => void;
+        _exitWrite: () => void;
+        _failWrite: (error: unknown) => unknown;
+    };
     readonly throwForeign?: (owner: object | undefined) => never;
 }
+interface ExtendedObjectHandler {
+    extension: ReactiveObjectExtension | undefined;
+    readonly deep: boolean;
+    readonly handler: ProxyHandler<object>;
+}
+interface ReactiveObjectIdentity {
+    readonly context: ReactiveObjectContext;
+    readonly raw: object;
+}
+export declare const REACTIVE_OBJECT_IDENTITY: unique symbol;
+/** Результат ReactiveObjectSupport.openWrite(). @internal */
+export type WriteMode = 0 | 1 | 2;
+export declare const WRITE_NESTED = 0;
+export declare const WRITE_OPENED = 1;
+export declare const WRITE_CALLBACK = 2;
 /** 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 */
@@ -34,3 +90,88 @@ export declare function disposeReactiveObjectContext(engine: object, disposedPol
  * @internal
  */
 export declare function reactiveObject<T extends object>(engine: object, value: T, createBridge: () => ReactivePropertySourceBridge): T;
+declare class ReactiveObjectContext {
+    private _admins;
+    private _arrayMethods;
+    private _bridge;
+    private _policy;
+    private _writeDepth;
+    private _openBridge;
+    private _openBoundary;
+    private _disposed;
+    private _extendedHandlers;
+    private _mutatorProxy;
+    private _mutatorTarget;
+    private _lockedTargets;
+    private readonly _handler;
+    private readonly _weakSelf;
+    constructor(bridge: ReactivePropertySourceBridge, policy: ReactiveObjectPolicy);
+    get owner(): object | undefined;
+    _setPolicy(policy: ReactiveObjectPolicy): void;
+    get disposed(): boolean;
+    support(): ReactiveObjectSupport;
+    claim(raw: object): void;
+    /** Запись raw, принадлежащая этому context, либо undefined. */
+    private _ownAdmin;
+    /**
+     * Запись raw этого context. Запись освобождённого или собранного владельца
+     * заменяется новой; живой чужой владелец отклоняет raw.
+     */
+    private _claimAdmin;
+    wrap(raw: object, extended?: ExtendedObjectHandler): object;
+    dispose(disposedPolicy: ReactiveObjectPolicy): void;
+    private _extensionHandler;
+    private _get;
+    private _set;
+    private _applySet;
+    private _define;
+    private _applyDefine;
+    private _delete;
+    private _applyDelete;
+    private _has;
+    private _ownKeys;
+    private _arrayMutator;
+    /**
+     * Raw массива для специализированного мутатора: только сразу после чтения
+     * метода через этот Proxy, вне отслеживания и для обычного Array.prototype.
+     * Иначе мутатор идёт прежним путём через ловушки Proxy.
+     *
+     * @internal
+     */
+    _fastArrayTarget(receiver: unknown): unknown[] | undefined;
+    /**
+     * Выполняет специализированный мутатор в границе записи без closure.
+     *
+     * @internal
+     */
+    _arrayWrite(operation: number, raw: unknown[], first: unknown, second: unknown, third: unknown, count: number): unknown;
+    private _arrayOperation;
+    private _splice;
+    private _moveArrayEntry;
+    private _setArrayEntry;
+    private _deleteArrayEntry;
+    private _viewOf;
+    private _trackValue;
+    private _trackHas;
+    private _trackIterate;
+    private _ensureTracking;
+    private _trigger;
+    private _triggerArrayShape;
+    private _write;
+    /**
+     * Проверяет право записи и открывает внешнюю границу без closure операции.
+     * WRITE_OPENED обязывает вызывающего завершить её через _closeWrite() или
+     * _failOpenWrite(). Пока граница открыта, _writeDepth не равен нулю, поэтому
+     * вложенная запись получает WRITE_NESTED и сохранённые поля не перезаписывает.
+     */
+    private _openWrite;
+    private _closeWrite;
+    /** Закрывает открытую границу после сбоя операции и возвращает ошибку для throw. */
+    private _failOpenWrite;
+    private _writeThroughPolicy;
+    private _unwrap;
+    private _requireBridge;
+}
+export declare function getReactiveObjectSupport(engine: object): ReactiveObjectSupport;
+export declare function isPlainReactiveValue(value: unknown): value is object;
+export {};

package/dist/reactivity/scope.d.ts

@@ -1,6 +1,7 @@
-import { DisposalFailure } from './disposal';
-import { RaphReactivity } from './engine';
-import { Disposer, EffectCallback, OwnedResource, OwnedSource, ReadonlySignal, ScopeChildren, ScopeLink, Signal, SourceFinalizer, WatchCallback, WatchOptions, WatchSource, WritableComputedOptions } from './types';
+import { DisposalFailure } from './disposal.js';
+import { RaphReactivity } from './engine.js';
+import { ReactivityEngine } from './engine-core.js';
+import { Disposer, EffectCallback, OwnedResource, OwnedSource, ReadonlySignal, ScopeChildren, ScopeLink, Signal, SourceFinalizer, WatchCallback, WatchOptions, WatchSource, WritableComputedOptions } from './types.js';
 /**
  * Запись источника в списке владельца: сама хранит связь с соседом и сама
  * освобождает источник, поэтому владельцу не нужна отдельная коллекция.
@@ -117,16 +118,16 @@ export declare abstract class ScopeOwner implements ScopeChildren<OwnedResource>
  * Проверки lifetime выполняют только owned handles; свободные signal() не проходят
  * через владельца. Класс не является узлом графа зависимостей.
  */
-export declare class ScopeNode extends ScopeOwner {
+export declare class ScopeNode<Engine extends ReactivityEngine = RaphReactivity> extends ScopeOwner {
     /**
      * Экземпляр, в котором создаются owned-ресурсы.
      */
-    readonly reactivity: RaphReactivity;
+    readonly reactivity: Engine;
     /**
      * Связывает владельца с реактивным экземпляром без создания нового графа.
      * @param reactivity Экземпляр, в котором создаются owned-ресурсы.
      */
-    constructor(reactivity: RaphReactivity);
+    constructor(reactivity: Engine);
     /**
      * Создаёт owned signal и регистрирует его финализатор.
      * Все методы возвращённого handle проверяют, что владелец ещё активен.

package/dist/reactivity/types.d.ts

@@ -96,11 +96,7 @@ export interface ReactiveNode<T = any> extends ScopeChildren<ReactiveNode>, Scop
     lastSub: ReactiveEdge | null;
     firstDep: ReactiveEdge | null;
     tailDep: ReactiveEdge | null;
-    depCount: number;
     subSearchCursor?: ReactiveEdge;
-    dependencyIndex?: Map<ReactiveNode, ReactiveEdge>;
-    dependencyLookupDebt?: number;
-    dependencyLookupSearches?: number;
     evaluate: (() => any) | undefined;
     cachedValue: T;
     pendingValue?: T;
@@ -108,6 +104,7 @@ export interface ReactiveNode<T = any> extends ScopeChildren<ReactiveNode>, Scop
     effectTask?: EffectTask;
     onStop?: Disposer;
     sourceHooks?: OwnedSourceHooks;
+    onUnobserved?: Disposer;
 }
 /**
  * Низкоуровневые read/write для raw-дорожки Bench Lab.
@@ -126,19 +123,20 @@ export interface ComputedAccess<T> {
     read: (this: ComputedAccess<unknown>) => T;
 }
 /**
- * Ленивый raw handle: до первого чтения поля ReactiveNode отсутствуют.
- * Partial описывает стадию материализации, а не ослабляет контракт готового узла.
+ * Raw handle computed, который сам является полной записью графа.
+ * Поля ReactiveNode выделяются при создании внутри объекта; read вызывается
+ * только с receiver (серия Raph Top-1, 2026-10-20).
  * @internal
  */
-export interface ComputedAccessHandle<T> extends Partial<ReactiveNode<T>>, ComputedAccess<T> {
+export interface ComputedAccessHandle<T> extends ReactiveNode<T>, ComputedAccess<T> {
     evaluate: (() => T) | undefined;
 }
 /**
- * Ленивый объектный computed: графовые поля становятся обязательными
- * только после initializeComputedHandle(). Отдельной записи графа не выделяет.
+ * Объектный computed, который сам является полной записью графа.
+ * Значение по-прежнему вычисляется лениво при первом get().
  * @internal
  */
-export interface ComputedSourceAccessHandle<T> extends Partial<ReactiveNode<T>>, ReadonlySignal<T> {
+export interface ComputedSourceAccessHandle<T> extends ReactiveNode<T>, ReadonlySignal<T> {
     evaluate: (() => T) | undefined;
 }
 /**
@@ -169,7 +167,6 @@ export interface OwnedSourceHooks {
  * @internal
  */
 export interface HandleReaders {
-    initializeComputed: <T>(this: ReadonlySignal<unknown>) => T;
-    initializeRaw: <T>(this: ComputedAccess<unknown>) => T;
+    read: <T>(this: ReadonlySignal<unknown> | ComputedAccess<unknown>) => T;
     peek: <T>(this: ReadonlySignal<unknown>) => T;
 }

package/dist/reactivity/watch.d.ts

@@ -1,4 +1,4 @@
-import { Disposer, EffectFactory, TrackedOperation, WatchCallback, WatchOptions, WatchSource } from './types';
+import { Disposer, EffectFactory, TrackedOperation, WatchCallback, WatchOptions, WatchSource } from './types.js';
 /**
  * Создаёт watch поверх переданной фабрики эффектов и политики чтения.
  * Фабрика обязана поддерживать второй аргумент onStop: он связывает окончательную

package/dist/runtime/RaphCompactExecutionRuntime.d.ts

@@ -0,0 +1,7 @@
+import { RaphExecutionRuntimeOptions, RaphRuntimeBase } from './RaphRuntimeBase.js';
+/** Известная композиция без Proxy-объектов; signals, watch, aggregates и phases общие. */
+export declare class RaphCompactExecutionRuntime extends RaphRuntimeBase<RaphCompactExecutionRuntime> {
+    readonly reactiveObjects: false;
+    readonly selectors: false;
+    constructor(options?: RaphExecutionRuntimeOptions);
+}

package/dist/runtime/RaphExecutionRuntime.d.ts

@@ -0,0 +1,6 @@
+import { RaphExecutionRuntimeOptions, RaphRuntimeBase } from './RaphRuntimeBase.js';
+export declare class RaphExecutionRuntime extends RaphRuntimeBase<RaphExecutionRuntime> {
+    readonly reactiveObjects: true;
+    readonly selectors: true;
+    constructor(options?: RaphExecutionRuntimeOptions);
+}