@raphy-js/raph 1.0.0-dev.18

package/dist/main.d.ts

@@ -0,0 +1,20 @@
+export { RaphCapabilityError, RaphConfigurationError, RaphDefaultInstanceError, RaphError, RaphFacadeDisposedError, } from './api/errors';
+export { Raph } from './api/Raph';
+export { RaphReactivityInstance } from './api/RaphReactivityInstance';
+export type { ConfiguredRaph, RaphConfigureOptions, RaphFlatConfigureOptions, RaphInstance, RaphInstanceDefinition, RaphInstanceDefinitions, RaphInstanceMode, RaphInstancesConfigureOptions, RaphReactiveApi, RaphReactivityApi, RaphReactivityConfigureOptions, RaphReactivityInstanceDefinition, RaphReactivityInstanceOptions, RaphRuntimeApi, RaphRuntimeConfigureOptions, RaphRuntimeInstanceDefinition, StrictRaphConfigureOptions, } from './api/types';
+export * from './entrypoints/runtime';
+export type { DataPathParseOptions, PathScalar, PathSegment, PlainDataPath, } from './path/data-path.types';
+export { DataPath } from './path/DataPath';
+export type { DerivedCollectionByKeyStrategy, DerivedFilterByKeyStrategy, DerivedFullStrategy, DerivedStrategy, } from './path/derived/derived-strategy.types';
+export { collectionByKey, filterByKey, full } from './path/derived/derived-strategy.utils';
+export { RaphDerivedHandle, RaphDerivedTargetWriteError } from './path/derived/RaphDerivedHandle';
+export type { DerivedOptions } from './path/derived/RaphDerivedHandle';
+export type { RaphMetaApi, RaphMetaEvents, RaphMetaMutationCause, RaphMetaMutationEvent, RaphMetaMutationKind, RaphMetaReadOptions, RaphMetaWatchCallback, RaphMetaWatchOptions, RaphMetaWriteOptions, } from './path/meta/meta.types';
+export { RaphMeta } from './path/meta/RaphMeta';
+export type { DataPathDef, PathEvent, PathEvents, PathMutationKind, PathOptions, PathWatchCallback, } from './path/path.types';
+export { RaphKernel } from './path/RaphKernel';
+export type { RaphKernelOptions, RaphKernelRoot, RaphKernelRuntime, } from './path/RaphKernel';
+export type { DataAdapter, DataObject, DefaultAdapterOptions, } from './path/storage/data-adapter.types';
+export { DefaultDataAdapter } from './path/storage/DefaultDataAdapter';
+export type { Disposer, ReadonlySignal, Signal, WatchOptions, WatchSource, WatchValue, WritableComputedOptions, } from './reactivity/types';
+export type PhaseName = string;

package/dist/path/DataPath.d.ts

@@ -0,0 +1,73 @@
+import { DataPathParseOptions, ParsedDataPath, ParsedPathMask, PathSegment, PlainDataPath } from './data-path.types';
+import { DataPathDef, PathOptions } from './path.types';
+/**
+ * Неизменяемый публичный value object строгой E2 path grammar.
+ */
+export declare class DataPath {
+    private static _cache;
+    private readonly _canonical;
+    private readonly _segments;
+    private _exact;
+    private _mask;
+    /**
+     * Сохраняет уже разобранный immutable path value.
+     */
+    private constructor();
+    /**
+     * Нормализует поддерживаемое определение пути в DataPath.
+     */
+    static from(input: DataPathDef, options?: DataPathParseOptions): DataPath;
+    /**
+     * Разбирает строковый path согласно строгой грамматике.
+     */
+    static fromString(path: string, options?: DataPathParseOptions): DataPath;
+    /**
+     * Восстанавливает DataPath из сериализованного представления.
+     */
+    static fromPlain(plain: PlainDataPath): DataPath;
+    /**
+     * Разбирает строку exact path без создания публичного value object.
+     * @internal
+     */
+    static _parseExactString(path: string, options?: PathOptions): ParsedDataPath;
+    /**
+     * Разбирает строку path mask без создания публичного value object.
+     * @internal
+     */
+    static _parseMaskString(mask: string): ParsedPathMask;
+    /**
+     * Формирует canonical path из уже проверенных сегментов.
+     * @internal
+     */
+    static _renderSegments(segments: readonly PathSegment[]): string;
+    /**
+     * Сериализует path в независимое plain-представление.
+     */
+    toPlain(): PlainDataPath;
+    /**
+     * Возвращает canonical строковое представление пути.
+     */
+    toStringPath(): string;
+    /**
+     * Возвращает canonical строковое представление пути.
+     */
+    toString(): string;
+    /**
+     * Возвращает immutable список сегментов пути.
+     */
+    segments(): readonly PathSegment[];
+    /**
+     * Проверяет соответствие exact path указанной маске.
+     */
+    static match(mask: DataPathDef, target: DataPathDef): boolean;
+    /**
+     * Возвращает exact path либо отклоняет wildcard-сегменты.
+     * @internal
+     */
+    _asExact(): ParsedDataPath;
+    /**
+     * Возвращает path mask с проверкой позиции wildcard.
+     * @internal
+     */
+    _asMask(): ParsedPathMask;
+}

package/dist/path/PathRouter.d.ts

@@ -0,0 +1,21 @@
+import { ParsedPathMask, PathSegment } from './data-path.types';
+/**
+ * Индексирует exact и wildcard path-masks без участия reactive graph.
+ */
+export declare class PathRouter<Payload> {
+    private readonly _root;
+    /**
+     * Регистрирует route mask и возвращает функцию удаления.
+     */
+    add(mask: ParsedPathMask, payload: Payload): () => void;
+    /**
+     * Возвращает routes, чьи masks соответствуют указанному событию.
+     */
+    match(path: readonly Exclude<PathSegment, {
+        kind: 'wildcard';
+    }>[]): Set<Payload>;
+    /**
+     * При замене root возвращает все зарегистрированные path masks.
+     */
+    matchAll(): Set<Payload>;
+}

package/dist/path/RaphKernel.d.ts

@@ -0,0 +1,169 @@
+import { DerivedOptions, RaphDerivedHandle } from './derived/RaphDerivedHandle';
+import { RaphMetaEvents, RaphMetaReadOptions, RaphMetaWatchOptions, RaphMetaWriteOptions } from './meta/meta.types';
+import { RaphMeta } from './meta/RaphMeta';
+import { DataPathDef, PathOptions, PathWatchCallback } from './path.types';
+import { DataAdapter, DataObject, DefaultAdapterOptions } from './storage/data-adapter.types';
+export type RaphKernelRoot = DataObject;
+export interface RaphKernelOptions {
+    readonly id?: string;
+    readonly initial?: RaphKernelRoot;
+    readonly adapter?: DataAdapter;
+    readonly adapterOptions?: DefaultAdapterOptions;
+}
+export interface RaphKernelRuntime {
+    dispose: () => void;
+    _beginKernelBatch?: () => void;
+    _endKernelBatch?: () => void;
+}
+/**
+ * Независимый владелец одного path data-plane без signal/runtime state.
+ */
+export declare class RaphKernel {
+    private static _kernelCounter;
+    readonly id: string;
+    private _paths;
+    private _derivedController;
+    private _runtimes;
+    private _metaController;
+    private _batchDepth;
+    private _runtimeMutationDepth;
+    private _stabilizing;
+    private _derivedWriteDepth;
+    /**
+     * Создаёт data/meta owner с независимым lifecycle и derived registry.
+     */
+    constructor(options?: RaphKernelOptions);
+    /**
+     * Показывает, освобождён ли Kernel.
+     */
+    get disposed(): boolean;
+    /**
+     * Формирует диагностический снимок materialized derived registry.
+     */
+    getDerivedSnapshot(): {
+        registrations: number;
+        errors: number;
+        pending: number;
+        stabilizing: boolean;
+    };
+    /**
+     * Возвращает лениво созданный metadata facade.
+     */
+    get meta(): RaphMeta;
+    /**
+     * Возвращает весь path-root Kernel.
+     */
+    get<T = RaphKernelRoot>(): T | undefined;
+    /**
+     * Возвращает значение по пути без создания отсутствующих данных.
+     */
+    get<T = unknown>(path: DataPathDef, options?: PathOptions): T | undefined;
+    /**
+     * Читает весь path-root Kernel.
+     */
+    peek<T = RaphKernelRoot>(): T | undefined;
+    /**
+     * Читает значение по пути без регистрации реактивной зависимости.
+     */
+    peek<T = unknown>(path: DataPathDef, options?: PathOptions): T | undefined;
+    /**
+     * Проверяет наличие значения по указанному пути.
+     */
+    has(path: DataPathDef, options?: PathOptions): boolean;
+    /**
+     * Записывает значение и публикует соответствующее изменение.
+     */
+    set<T>(path: DataPathDef, value: T, options?: PathOptions): void;
+    /**
+     * Объединяет значение по пути и публикует соответствующее изменение.
+     */
+    merge(path: DataPathDef, value: unknown, options?: PathOptions): void;
+    /**
+     * Удаляет значение по пути и публикует изменение при наличии данных.
+     */
+    delete(path: DataPathDef, options?: PathOptions): void;
+    /**
+     * Выполняет операцию в общей синхронной batch boundary.
+     */
+    batch<T>(operation: () => T): T;
+    /**
+     * Подписывает callback на подходящие изменения и возвращает disposer.
+     */
+    watch(masks: DataPathDef | readonly DataPathDef[], callback: PathWatchCallback): () => void;
+    /**
+     * Возвращает metadata указанного data-owner.
+     */
+    getMeta(path: DataPathDef, namespace?: string, options?: RaphMetaReadOptions): unknown;
+    /**
+     * Проверяет наличие metadata у указанного data-owner.
+     */
+    hasMeta(path: DataPathDef, namespace?: string, options?: RaphMetaReadOptions): boolean;
+    /**
+     * Записывает metadata указанного data-owner.
+     */
+    setMeta(path: DataPathDef, namespace: string, value: unknown, options?: RaphMetaWriteOptions): void;
+    /**
+     * Объединяет metadata указанного data-owner.
+     */
+    mergeMeta(path: DataPathDef, namespace: string, value: unknown, options?: RaphMetaWriteOptions): void;
+    /**
+     * Удаляет metadata указанного data-owner.
+     */
+    deleteMeta(path: DataPathDef, namespace?: string, options?: RaphMetaWriteOptions): void;
+    /**
+     * Подписывает runtime adapter на metadata-события Kernel.
+     * @internal
+     */
+    _watchMeta(maskOrMasks: DataPathDef | readonly DataPathDef[], callback: (payload: RaphMetaEvents) => void, options?: RaphMetaWatchOptions, afterPublish?: (invalidate: boolean) => void): () => void;
+    /**
+     * Создаёт управляемое derived-представление source path в target path.
+     */
+    derive<TSource, TTarget>(options: DerivedOptions<TSource, TTarget>): RaphDerivedHandle<TSource, TTarget>;
+    /**
+     * Регистрирует runtime, разделяющий этот Kernel.
+     * @internal
+     */
+    _attachRuntime(runtime: RaphKernelRuntime): void;
+    /**
+     * Удаляет runtime из shared Kernel registry.
+     * @internal
+     */
+    _detachRuntime(runtime: RaphKernelRuntime): void;
+    /**
+     * Освобождает shared runtimes, derived handles и data/meta state Kernel.
+     */
+    dispose(): void;
+    /**
+     * Пересчитывает указанный derived handle через его стратегию.
+     * @internal
+     */
+    _recomputeDerived<TSource, TTarget>(handle: RaphDerivedHandle<TSource, TTarget>): void;
+    /**
+     * Удаляет derived handle из registry и освобождает его routes.
+     * @internal
+     */
+    _removeDerived(handle: RaphDerivedHandle<any, any>): void;
+    private get _store();
+    private get _metadata();
+    /** Keeps every attached Runtime quiescent until one Kernel publication completes. */
+    private _withAttachedRuntimeBoundary;
+    private _assertWritablePath;
+    private _writeDerivedTarget;
+    private _mutateDerived;
+    private _runDerivedBatch;
+    private _mutateWithMetaLifecycle;
+    private _pruneMissingMetaOwners;
+    private _metaPath;
+    private _exactMetaPath;
+    private _assertMetaNamespace;
+    private _assertMetaOwner;
+    private _queueDerived;
+    private _queueDerivedReplacement;
+    private _replaceDerivedTarget;
+    private _stabilizeDerived;
+    private _recomputePendingDerived;
+    private _recomputeDerivedFull;
+    private _recomputeDerivedCollection;
+    private _recomputeDerivedFilter;
+    private _patchSingleFilterMembership;
+}

package/dist/path/data-path.types.d.ts

@@ -0,0 +1,34 @@
+import { PathOptions } from './path.types';
+export type PathScalar = string | number | boolean | null;
+export type PathSegment = {
+    readonly kind: 'key';
+    readonly key: string;
+} | {
+    readonly kind: 'index';
+    readonly index: number;
+} | {
+    readonly kind: 'selector';
+    readonly key: string;
+    readonly value: PathScalar;
+} | {
+    readonly kind: 'wildcard';
+    readonly indexed: boolean;
+};
+export interface ParsedDataPath {
+    readonly canonical: string;
+    readonly segments: readonly Exclude<PathSegment, {
+        kind: 'wildcard';
+    }>[];
+}
+export interface ParsedPathMask {
+    readonly canonical: string;
+    readonly deep: boolean;
+    readonly segments: readonly PathSegment[];
+}
+export interface DataPathParseOptions extends PathOptions {
+    readonly wildcardDynamic?: boolean;
+}
+export interface PlainDataPath {
+    readonly deepOnTail?: boolean;
+    readonly segs: readonly unknown[];
+}

package/dist/path/data-path.utils.d.ts

@@ -0,0 +1,9 @@
+import { ParsedDataPath, ParsedPathMask } from './data-path.types';
+import { DataPathDef, PathOptions } from './path.types';
+export declare function parseDataPath(path: DataPathDef, options?: PathOptions): ParsedDataPath;
+export declare function parsePathMask(mask: DataPathDef): ParsedPathMask;
+/**
+ * Формирует masks для публикации всех отношений exact path.
+ * @internal
+ */
+export declare function pathRelationMasks(path: ParsedDataPath): readonly string[];

package/dist/path/derived/DerivedRegistry.d.ts

@@ -0,0 +1,67 @@
+import { ParsedDataPath } from '../data-path.types';
+import { CollectionDerivedState, DerivedCollectionKey } from './derived-collection.types';
+import { RaphDerivedHandle } from './RaphDerivedHandle';
+/**
+ * Владеет регистрациями, routes и pending-state materialized derived.
+ * Вычисление значений остаётся у Kernel, который координирует data-plane.
+ */
+export declare class DerivedRegistry {
+    private _router;
+    private _handles;
+    private _matches;
+    private _pending;
+    private _collections;
+    private _counter;
+    /**
+     * Возвращает число зарегистрированных записей.
+     */
+    get size(): number;
+    /**
+     * Возвращает очередь derived-вычислений, ожидающих стабилизации.
+     */
+    get pending(): Set<RaphDerivedHandle<any, any>> | undefined;
+    /**
+     * Выделяет следующий стабильный идентификатор registry.
+     */
+    nextId(): string;
+    /**
+     * Проверяет наличие derived handle с указанным id.
+     */
+    has(id: string): boolean;
+    /**
+     * Возвращает зарегистрированные derived handles.
+     */
+    values(): IterableIterator<RaphDerivedHandle<any, any>>;
+    /**
+     * Возвращает внутреннее состояние зарегистрированного handle.
+     */
+    state(handle: RaphDerivedHandle<any, any>): CollectionDerivedState | undefined;
+    /**
+     * Регистрирует derived handle и его зависимости.
+     */
+    register(handle: RaphDerivedHandle<any, any>, from: ParsedDataPath, strategy: {
+        readonly kind: 'collection-by-key' | 'filter-by-key';
+        readonly key: string;
+    } | undefined): void;
+    /**
+     * Удаляет регистрацию и связанные pending-записи.
+     */
+    remove(handle: RaphDerivedHandle<any, any>): void;
+    /**
+     * Добавляет derived handle в очередь пересчёта.
+     */
+    queue(path: ParsedDataPath): void;
+    /**
+     * Запоминает полную замену, которую нужно применить при стабилизации.
+     */
+    queueReplacement(path: ParsedDataPath, keys: ReadonlySet<DerivedCollectionKey>): void;
+    /**
+     * Сбрасывает pending-состояние после опустошения очереди.
+     */
+    clearPendingIfEmpty(): void;
+    /**
+     * Освобождает все handles и очищает derived registry.
+     */
+    dispose(): void;
+    private _matching;
+}

package/dist/path/derived/RaphDerivedHandle.d.ts

@@ -0,0 +1,97 @@
+import { DataPathDef } from '../path.types';
+import { RaphKernel } from '../RaphKernel';
+import { DerivedStrategy } from './derived-strategy.types';
+/**
+ * Сообщает о прямой записи в target, которым владеет derived-вычисление.
+ */
+export declare class RaphDerivedTargetWriteError extends Error {
+    /**
+     * Создаёт ошибку с canonical path защищённого derived target.
+     */
+    constructor(path: string);
+}
+export interface DerivedOptions<TSource = unknown, TTarget = unknown> {
+    readonly id?: string;
+    readonly from: DataPathDef;
+    readonly to: DataPathDef;
+    readonly strategy?: DerivedStrategy;
+    readonly compute: (source: TSource) => TTarget;
+    readonly immediate?: boolean;
+    readonly disposeTarget?: 'keep' | 'delete';
+}
+/**
+ * Управляет lifecycle одной materialized path dependency.
+ */
+export declare class RaphDerivedHandle<TSource = unknown, TTarget = unknown> {
+    readonly id: string;
+    readonly options: DerivedOptions<TSource, TTarget>;
+    private readonly _kernel;
+    private _removeRoutes;
+    private _paused;
+    private _disposed;
+    private _status;
+    private _lastError;
+    /**
+     * Создаёт internal handle, которым управляет owning Kernel.
+     * @internal
+     */
+    constructor(kernel: RaphKernel, id: string, options: DerivedOptions<TSource, TTarget>);
+    /**
+     * Показывает, приостановлено ли derived-вычисление.
+     */
+    get paused(): boolean;
+    /**
+     * Показывает, освобождён ли derived handle.
+     */
+    get disposed(): boolean;
+    /**
+     * Возвращает состояние последнего derived-пересчёта.
+     */
+    get status(): 'idle' | 'success' | 'error';
+    /**
+     * Возвращает последнюю ошибку derived-пересчёта либо null.
+     */
+    get lastError(): Error | null;
+    /**
+     * Фиксирует успешное завершение derived-пересчёта.
+     * @internal
+     */
+    _recordSuccess(): void;
+    /**
+     * Фиксирует ошибку derived-пересчёта без потери handle.
+     * @internal
+     */
+    _recordFailure(error: unknown): void;
+    /**
+     * Приостанавливает автоматические пересчёты без освобождения handle.
+     */
+    pause(): void;
+    /**
+     * Возобновляет пересчёты и синхронизирует устаревший target.
+     */
+    resume(): void;
+    /**
+     * Принудительно пересчитывает derived target.
+     */
+    recompute(): void;
+    /**
+     * Удаляет derived registration и применяет выбранную политику target cleanup.
+     */
+    dispose(): void;
+    /**
+     * Сохраняет disposers source routes текущей стратегии.
+     * @internal
+     */
+    _attachRoutes(removers: readonly (() => void)[]): void;
+    /**
+     * Отсоединяет все source routes текущей стратегии.
+     * @internal
+     */
+    _detachRoutes(): void;
+    /**
+     * Помечает handle освобождённым после cleanup owning Kernel.
+     * @internal
+     */
+    _disposeFromKernel(): void;
+    private _assertAlive;
+}

package/dist/path/derived/derived-collection.types.d.ts

@@ -0,0 +1,12 @@
+import { ParsedDataPath } from '../data-path.types';
+export type DerivedCollectionKey = string | number;
+export interface CollectionDerivedState {
+    readonly from: ParsedDataPath;
+    readonly kind: 'collection-by-key' | 'filter-by-key';
+    readonly key: string;
+    initialized: boolean;
+    full: boolean;
+    readonly keys: Set<DerivedCollectionKey>;
+    sourceIndex: Map<DerivedCollectionKey, number> | undefined;
+    targetIndex: Map<DerivedCollectionKey, number> | undefined;
+}

package/dist/path/derived/derived-collection.utils.d.ts

@@ -0,0 +1,20 @@
+import { ParsedDataPath } from '../data-path.types';
+import { DataPathDef } from '../path.types';
+import { DerivedCollectionKey } from './derived-collection.types';
+export declare function collectionMutationImpact(source: ParsedDataPath, keyField: string, mutation: ParsedDataPath): {
+    readonly kind: 'full';
+} | {
+    readonly kind: 'key';
+    readonly key: DerivedCollectionKey;
+};
+export declare function keyedPath(collection: DataPathDef, keyField: string, key: DerivedCollectionKey): string;
+export declare function validateFullCollection(id: string, keyField: string, source: unknown, output: unknown): void;
+export declare function validateIncrementalCollection(id: string, keyField: string, inputKeys: readonly DerivedCollectionKey[], output: unknown): void;
+export declare function validateFullFilter(id: string, keyField: string, source: unknown, output: unknown): void;
+export declare function validateIncrementalFilter(id: string, keyField: string, inputKeys: readonly DerivedCollectionKey[], output: unknown): void;
+export declare function collectionKeys(collection: readonly unknown[], keyField: string, label: string): Array<DerivedCollectionKey | undefined>;
+export declare function collectionIndex(collection: readonly unknown[], keyField: string, label: string): Map<DerivedCollectionKey, number>;
+export declare function indexesAreStale(collection: readonly unknown[], keyField: string, index: ReadonlyMap<DerivedCollectionKey, number>, keys: ReadonlySet<DerivedCollectionKey>): boolean;
+export declare function collectionError(id: string, message: string): TypeError;
+export declare function filterError(id: string, message: string): TypeError;
+export declare function cloneMaterializedValue<T>(value: T): T;

package/dist/path/derived/derived-strategy.types.d.ts

@@ -0,0 +1,12 @@
+export interface DerivedFullStrategy {
+    readonly kind: 'full';
+}
+export interface DerivedCollectionByKeyStrategy {
+    readonly kind: 'collection-by-key';
+    readonly key: string;
+}
+export interface DerivedFilterByKeyStrategy {
+    readonly kind: 'filter-by-key';
+    readonly key: string;
+}
+export type DerivedStrategy = DerivedFullStrategy | DerivedCollectionByKeyStrategy | DerivedFilterByKeyStrategy;

package/dist/path/derived/derived-strategy.utils.d.ts

@@ -0,0 +1,4 @@
+import { DerivedCollectionByKeyStrategy, DerivedFilterByKeyStrategy, DerivedFullStrategy } from './derived-strategy.types';
+export declare function full(): DerivedFullStrategy;
+export declare function collectionByKey(key: string): DerivedCollectionByKeyStrategy;
+export declare function filterByKey(key: string): DerivedFilterByKeyStrategy;

package/dist/path/meta/MetaController.d.ts

@@ -0,0 +1,85 @@
+import { DataPathDef } from '../path.types';
+import { RaphKernel } from '../RaphKernel';
+import { RaphMetaEvents, RaphMetaMutationCause, RaphMetaMutationEvent, RaphMetaWatchOptions, RaphMetaWriteOptions } from './meta.types';
+import { DataPath } from '../DataPath';
+import { RaphMeta } from './RaphMeta';
+/**
+ * Владеет metadata storage, routing и пакетной публикацией.
+ * Kernel сообщает контроллеру только о lifecycle data-owner.
+ */
+export declare class MetaController {
+    private readonly _kernel;
+    private readonly _ownerExists;
+    private readonly _publicationDeferred;
+    private _facade;
+    private _store;
+    private _router;
+    private _pending;
+    private _publishing;
+    private _watcherCount;
+    private _deferredWatcherCount;
+    /**
+     * Создаёт lifecycle-контроллер metadata для одного Kernel.
+     */
+    constructor(_kernel: RaphKernel, _ownerExists: (path: DataPathDef) => boolean, _publicationDeferred: () => boolean);
+    /**
+     * Возвращает metadata facade, принадлежащий контроллеру.
+     */
+    get facade(): RaphMeta;
+    /**
+     * Возвращает число зарегистрированных записей.
+     */
+    get size(): number;
+    /**
+     * Показывает, есть ли активные синхронные metadata/path watchers.
+     */
+    get hasWatchers(): boolean;
+    /**
+     * Показывает, есть ли watchers с отложенной публикацией.
+     */
+    get hasDeferredWatchers(): boolean;
+    /**
+     * Возвращает значение по пути без создания отсутствующих данных.
+     */
+    get(path: DataPath, namespace?: string): unknown;
+    /**
+     * Проверяет наличие значения по указанному пути.
+     */
+    has(path: DataPath, namespace?: string): boolean;
+    /**
+     * Записывает значение и публикует соответствующее изменение.
+     */
+    set(path: DataPath, namespace: string, value: unknown, options?: RaphMetaWriteOptions): void;
+    /**
+     * Объединяет значение по пути и публикует соответствующее изменение.
+     */
+    merge(path: DataPath, namespace: string, value: unknown, options?: RaphMetaWriteOptions): void;
+    /**
+     * Удаляет значение по пути и публикует изменение при наличии данных.
+     */
+    delete(path: DataPath, namespace?: string, options?: RaphMetaWriteOptions): boolean;
+    /**
+     * Удаляет metadata всего поддерева указанного data-owner.
+     */
+    deleteSubtree(path: DataPath, cause: Extract<RaphMetaMutationCause, 'owner-delete' | 'owner-replaced'>): void;
+    /**
+     * Удаляет metadata, владельцы которой отсутствуют в data tree.
+     */
+    pruneMissing(path: DataPath, cause: Extract<RaphMetaMutationCause, 'owner-delete' | 'owner-replaced'>): void;
+    /**
+     * Подписывает callback на подходящие изменения и возвращает disposer.
+     */
+    watch(maskOrMasks: DataPathDef | readonly DataPathDef[], callback: (payload: RaphMetaEvents) => void, options?: RaphMetaWatchOptions, afterPublish?: (invalidate: boolean) => void): () => void;
+    /**
+     * Добавляет событие в текущую batch либо публикует его сразу.
+     */
+    record(kind: RaphMetaMutationEvent['kind'], path: DataPath, namespace: string | null, cause: RaphMetaMutationCause, options?: RaphMetaWriteOptions): void;
+    /**
+     * Публикует накопленные metadata-события с учётом watcher mode.
+     */
+    publish(): void;
+    /**
+     * Очищает metadata storage, subscriptions и pending publication state.
+     */
+    dispose(): void;
+}