@raphy-js/raph 1.0.0-dev.2

package/dist/path/PathEventHub.d.ts

@@ -0,0 +1,48 @@
+import { DataPathDef, PathEvent, PathWatchCallback } from './path.types';
+/**
+ * Общий dormant event/watch lifecycle для встроенного и adapter path-store.
+ */
+export declare class PathEventHub {
+    private readonly _transactionErrorMessage;
+    private _router;
+    private _events;
+    private _transactionDepth;
+    private _watcherCount;
+    private _publishing;
+    /**
+     * Создаёт общий transaction и publication boundary для path store.
+     */
+    constructor(_transactionErrorMessage: string);
+    /**
+     * Показывает, есть ли watchers, ради которых нужно сохранять значения событий.
+     */
+    get hasWatchers(): boolean;
+    /**
+     * Возвращает накопленные события текущей transaction.
+     * @internal
+     */
+    get events(): readonly PathEvent[] | undefined;
+    /**
+     * Возвращает внутренний path router для диагностики store.
+     * @internal
+     */
+    get router(): unknown;
+    /**
+     * Возвращает число активных watchers.
+     * @internal
+     */
+    get watcherCount(): number;
+    /**
+     * Добавляет событие в текущую transaction либо публикует его сразу.
+     */
+    record(event: PathEvent): void;
+    /**
+     * Выполняет операцию в общей синхронной transaction boundary.
+     */
+    transaction<T>(operation: () => T): T;
+    /**
+     * Подписывает callback на подходящие изменения и возвращает disposer.
+     */
+    watch(maskOrMasks: DataPathDef | readonly DataPathDef[], callback: PathWatchCallback): () => void;
+    private _publish;
+}

package/dist/path/PathStore.d.ts

@@ -0,0 +1,51 @@
+import { DataPathDef, PathApi, PathOptions, PathWatchCallback } from './path.types';
+/**
+ * Владеет одним независимым path-root, mutation log и watch-router.
+ */
+export declare class PathStore implements PathApi {
+    private _root;
+    private readonly _eventHub;
+    /**
+     * Возвращает внутренний router для диагностического контракта Kernel.
+     * @internal
+     */
+    private get _router();
+    private get _events();
+    private get _watcherCount();
+    /**
+     * Возвращает значение по пути без создания отсутствующих данных.
+     */
+    get<T = unknown>(path: DataPathDef, options?: PathOptions): 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;
+    /**
+     * Выполняет операцию в общей синхронной transaction boundary.
+     */
+    transaction<T>(operation: () => T): T;
+    /**
+     * Подписывает callback на подходящие изменения и возвращает disposer.
+     */
+    watch(maskOrMasks: DataPathDef | readonly DataPathDef[], callback: PathWatchCallback): () => void;
+    private _setRoot;
+    private _mergeRoot;
+    private _deleteRoot;
+    private _recordRootEvent;
+}

package/dist/path/RaphDerivedHandle.d.ts

@@ -0,0 +1,97 @@
+import { DerivedStrategy } from './derived-strategies';
+import { DataPathDef } from './path.types';
+import { RaphKernel } from './RaphKernel';
+/**
+ * Сообщает о прямой записи в 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/RaphKernel.d.ts

@@ -0,0 +1,166 @@
+import { DataAdapter, DataObject, DefaultAdapterOptions } from './data-adapter';
+import { RaphMetaEvents, RaphMetaReadOptions, RaphMetaWatchOptions, RaphMetaWriteOptions } from './meta.types';
+import { DataPathDef, PathOptions, PathWatchCallback } from './path.types';
+import { DerivedOptions, RaphDerivedHandle } from './RaphDerivedHandle';
+import { RaphMeta } from './RaphMeta';
+export type RaphKernelRoot = DataObject;
+export interface RaphKernelOptions {
+    readonly id?: string;
+    readonly initial?: RaphKernelRoot;
+    readonly adapter?: DataAdapter;
+    readonly adapterOptions?: DefaultAdapterOptions;
+}
+export interface RaphKernelRuntime {
+    dispose: () => void;
+    _beginKernelTransaction?: () => void;
+    _endKernelTransaction?: () => 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 _transactionDepth;
+    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;
+    /**
+     * Выполняет операцию в общей синхронной transaction boundary.
+     */
+    transaction<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();
+    private _assertWritablePath;
+    private _writeDerivedTarget;
+    private _mutateDerived;
+    private _runDerivedTransaction;
+    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/RaphMeta.d.ts

@@ -0,0 +1,45 @@
+import { RaphMetaApi, RaphMetaReadOptions, RaphMetaWatchCallback, RaphMetaWatchOptions, RaphMetaWriteOptions } from './meta.types';
+import { DataPathDef } from './path.types';
+import { RaphKernel } from './RaphKernel';
+export interface RaphMetaBinding {
+    readonly assertReadable?: () => void;
+    readonly assertWritable?: () => void;
+    readonly runWrite?: <Result>(operation: () => Result, invalidate: boolean) => Result;
+    readonly watch?: (masks: DataPathDef | readonly DataPathDef[], callback: RaphMetaWatchCallback, options: RaphMetaWatchOptions) => () => void;
+}
+/**
+ * Тонкий фасад отдельного Kernel-owned Meta-plane.
+ */
+export declare class RaphMeta implements RaphMetaApi {
+    private readonly _kernel;
+    private readonly _binding;
+    /**
+     * Создаёт metadata facade поверх указанного Kernel.
+     */
+    constructor(_kernel: RaphKernel, _binding?: RaphMetaBinding);
+    /**
+     * Возвращает значение по пути без создания отсутствующих данных.
+     */
+    get(path: DataPathDef, namespace?: string, options?: RaphMetaReadOptions): unknown;
+    /**
+     * Проверяет наличие значения по указанному пути.
+     */
+    has(path: DataPathDef, namespace?: string, options?: RaphMetaReadOptions): boolean;
+    /**
+     * Записывает значение и публикует соответствующее изменение.
+     */
+    set(path: DataPathDef, namespace: string, value: unknown, options?: RaphMetaWriteOptions): void;
+    /**
+     * Объединяет значение по пути и публикует соответствующее изменение.
+     */
+    merge(path: DataPathDef, namespace: string, value: unknown, options?: RaphMetaWriteOptions): void;
+    /**
+     * Удаляет значение по пути и публикует изменение при наличии данных.
+     */
+    delete(path: DataPathDef, namespace?: string, options?: RaphMetaWriteOptions): void;
+    /**
+     * Подписывает callback на metadata-изменения и возвращает disposer.
+     */
+    watch(masks: DataPathDef | readonly DataPathDef[], callback: RaphMetaWatchCallback, options?: RaphMetaWatchOptions): () => void;
+    private _write;
+}

package/dist/path/RaphMetaStore.d.ts

@@ -0,0 +1,45 @@
+import { DataPath } from './data-path';
+/**
+ * Kernel-owned дерево metadata, адресованное каноническими DataPath.
+ */
+export declare class RaphMetaStore {
+    private readonly _root;
+    size: number;
+    /**
+     * Возвращает значение по пути без создания отсутствующих данных.
+     */
+    get(path: DataPath, namespace?: string): unknown;
+    /**
+     * Проверяет наличие значения по указанному пути.
+     */
+    has(path: DataPath, namespace?: string): boolean;
+    /**
+     * Записывает значение namespace в metadata tree.
+     */
+    set(path: DataPath, namespace: string, value: unknown): void;
+    /**
+     * Объединяет object metadata либо заменяет значение namespace.
+     */
+    merge(path: DataPath, namespace: string, value: unknown): void;
+    /**
+     * Удаляет namespace либо все metadata указанного owner.
+     */
+    delete(path: DataPath, namespace?: string): boolean;
+    /**
+     * Удаляет metadata всего поддерева указанного data-owner.
+     */
+    deleteSubtree(path: DataPath): DataPath[];
+    /**
+     * Удаляет metadata, владельцы которой отсутствуют в data tree.
+     */
+    pruneMissing(path: DataPath, ownerExists: (candidate: DataPath) => boolean): DataPath[];
+    /**
+     * Полностью очищает metadata storage.
+     */
+    clear(): DataPath[];
+    private _find;
+    private _ensure;
+    private _findStack;
+    private _pruneEmpty;
+    private _pruneMissingNode;
+}

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

@@ -0,0 +1,78 @@
+import { DataPathDef, PathOptions } from './path.types';
+export type DataObject = Record<string, unknown> | unknown[];
+export interface DataAdapter {
+    root: () => DataObject;
+    has?: (path: DataPathDef, options?: PathOptions) => boolean;
+    get: (path: DataPathDef, options?: PathOptions) => unknown;
+    set: (path: DataPathDef, value: unknown, options?: PathOptions) => void;
+    delete: (path: DataPathDef, options?: PathOptions) => void;
+    merge: (path: DataPathDef, value: unknown, options?: PathOptions) => void;
+    indexOf?: (path: DataPathDef, options?: PathOptions) => number;
+}
+export interface DefaultAdapterOptions {
+    readonly arrayDelete?: 'splice' | 'unset';
+    readonly autoCreate?: boolean;
+    readonly indexEnabled?: boolean;
+    readonly indexStrategy?: 'lazy-key' | 'eager-all-keys';
+}
+/**
+ * Настраиваемый in-memory adapter, включаемый явно.
+ * Kernel без опций продолжает работать напрямую через PathStore без дополнительной ветки.
+ */
+export declare class DefaultDataAdapter implements DataAdapter {
+    private _root;
+    private readonly _options;
+    private _indexes;
+    /**
+     * Создаёт in-memory adapter с заданным начальным root и опциями.
+     */
+    constructor(initial?: DataObject, options?: DefaultAdapterOptions);
+    /**
+     * Возвращает текущий корневой объект adapter.
+     */
+    root(): DataObject;
+    /**
+     * Создаёт изолированную copy-on-write проекцию для синхронной проверки mutation.
+     */
+    fork(): DefaultDataAdapter;
+    /**
+     * Заменяет корневой объект без path-level публикации.
+     */
+    replaceRoot(root: DataObject): void;
+    /**
+     * Обновляет изменяемые опции adapter и сбрасывает построенные indexes.
+     */
+    options(options: DefaultAdapterOptions): void;
+    /**
+     * Возвращает значение по пути без создания отсутствующих данных.
+     */
+    get(path: DataPathDef, options?: PathOptions): unknown;
+    /**
+     * Проверяет наличие значения по указанному пути.
+     */
+    has(path: DataPathDef, options?: PathOptions): boolean;
+    /**
+     * Записывает значение по пути и обновляет затронутые selector indexes.
+     */
+    set(path: DataPathDef, value: unknown, options?: PathOptions): void;
+    /**
+     * Объединяет object value либо заменяет значение по пути.
+     */
+    merge(path: DataPathDef, value: unknown, options?: PathOptions): void;
+    /**
+     * Удаляет значение согласно arrayDelete policy adapter.
+     */
+    delete(path: DataPathDef, options?: PathOptions): void;
+    /**
+     * Находит индекс элемента массива по selector-сегменту.
+     */
+    indexOf(path: DataPathDef, options?: PathOptions): number;
+    private _read;
+    private _readSegment;
+    private _readOrCreateChild;
+    private _writeSegment;
+    private _invalidateArray;
+    private _invalidateIndexKey;
+    private _findSelector;
+    private _createIndex;
+}

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

@@ -0,0 +1,4 @@
+export declare function createDataDraft<T extends object>(root: T, onArrayChange: (array: any[]) => void): {
+    root: T;
+    unchangedArray(array: any[], key: string): any[] | null;
+};

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

@@ -0,0 +1,97 @@
+import { DataPathDef, 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[];
+}
+/**
+ * Неизменяемый публичный 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;
+    /**
+     * Сериализует 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;
+}
+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-collection.d.ts

@@ -0,0 +1,30 @@
+import { ParsedDataPath } from './data-path';
+import { DataPathDef } from './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;
+}
+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;