@frostpillar/frostpillar-btree 0.2.5 → 0.2.7

package/dist/concurrency/ConcurrentInMemoryBTree.d.ts

@@ -1,41 +1,25 @@
-import { type BTreeEntry, type BTreeStats, type EntryId, type RangeBounds } from '../InMemoryBTree.js';
+import { InMemoryBTree, type BTreeEntry, type BTreeJSON, type BTreeStats, type EntryId, type RangeBounds } from '../InMemoryBTree.js';
+import type { KeyComparator } from '../btree/types.js';
 import type { ConcurrentInMemoryBTreeConfig } from './types.js';
 export declare class ConcurrentInMemoryBTree<TKey, TValue> {
-    private readonly store;
-    private readonly maxRetries;
-    private readonly maxSyncMutationsPerBatch;
+    private readonly coord;
+    private readonly compareKeys;
     private readonly duplicateKeys;
-    private readonly configFingerprint;
-    private readonly readMode;
-    private readonly tree;
-    private currentVersion;
-    private operationQueue;
-    private initSeen;
     constructor(config: ConcurrentInMemoryBTreeConfig<TKey, TValue>);
     sync(): Promise<void>;
-    private syncUnlocked;
-    private applyMutationLocal;
-    private runExclusive;
-    private readOp;
-    /**
-     * Appends a mutation to the shared store using optimistic concurrency and,
-     * on success, applies the same mutation locally in this method.
-     *
-     * The `evaluate` callback is called against the current (synced) local tree to
-     * decide whether and what mutation to append. If the store append fails due to a
-     * concurrent write, the tree is re-synced and `evaluate` is invoked again.
-     *
-     * The callback MUST be a pure function: it must not produce side effects and must
-     * return the same logical result for equivalent tree states, because it may be
-     * called multiple times across retries.
-     *
-     */
-    private appendMutationAndApplyUnlocked;
+    syncThenRead<TResult>(fn: (tree: InMemoryBTree<TKey, TValue>) => TResult): Promise<TResult>;
     put(key: TKey, value: TValue): Promise<EntryId>;
     remove(key: TKey): Promise<BTreeEntry<TKey, TValue> | null>;
     removeById(entryId: EntryId): Promise<BTreeEntry<TKey, TValue> | null>;
     updateById(entryId: EntryId, value: TValue): Promise<BTreeEntry<TKey, TValue> | null>;
     popFirst(): Promise<BTreeEntry<TKey, TValue> | null>;
+    popLast(): Promise<BTreeEntry<TKey, TValue> | null>;
+    putMany(entries: readonly {
+        key: TKey;
+        value: TValue;
+    }[]): Promise<EntryId[]>;
+    deleteRange(startKey: TKey, endKey: TKey, options?: RangeBounds): Promise<number>;
+    clear(): Promise<void>;
     get(key: TKey): Promise<TValue | null>;
     hasKey(key: TKey): Promise<boolean>;
     findFirst(key: TKey): Promise<BTreeEntry<TKey, TValue> | null>;
@@ -47,10 +31,19 @@ export declare class ConcurrentInMemoryBTree<TKey, TValue> {
     getStats(): Promise<BTreeStats>;
     peekFirst(): Promise<BTreeEntry<TKey, TValue> | null>;
     peekLast(): Promise<BTreeEntry<TKey, TValue> | null>;
-    popLast(): Promise<BTreeEntry<TKey, TValue> | null>;
     peekById(entryId: EntryId): Promise<BTreeEntry<TKey, TValue> | null>;
     count(startKey: TKey, endKey: TKey, options?: RangeBounds): Promise<number>;
     nextHigherKey(key: TKey): Promise<TKey | null>;
     nextLowerKey(key: TKey): Promise<TKey | null>;
     getPairOrNextLower(key: TKey): Promise<BTreeEntry<TKey, TValue> | null>;
+    entries(): Promise<BTreeEntry<TKey, TValue>[]>;
+    entriesReversed(): Promise<BTreeEntry<TKey, TValue>[]>;
+    keys(): Promise<TKey[]>;
+    values(): Promise<TValue[]>;
+    forEach(callback: (entry: BTreeEntry<TKey, TValue>) => void): Promise<void>;
+    forEachRange(startKey: TKey, endKey: TKey, callback: (entry: BTreeEntry<TKey, TValue>) => void, options?: RangeBounds): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<BTreeEntry<TKey, TValue>>;
+    clone(): Promise<InMemoryBTree<TKey, TValue>>;
+    toJSON(): Promise<BTreeJSON<TKey, TValue>>;
+    static fromJSON<TKey, TValue>(json: BTreeJSON<TKey, TValue>, compareKeys: KeyComparator<TKey>): InMemoryBTree<TKey, TValue>;
 }

package/dist/concurrency/coordinator.d.ts

@@ -0,0 +1,21 @@
+import { InMemoryBTree } from '../InMemoryBTree.js';
+import type { BTreeMutation, ReadMode, SharedTreeStore } from './types.js';
+import { type MutationResult } from './helpers.js';
+export declare class Coordinator<TKey, TValue> {
+    readonly tree: InMemoryBTree<TKey, TValue>;
+    readonly store: SharedTreeStore<TKey, TValue>;
+    readonly maxRetries: number;
+    readonly maxSyncMutationsPerBatch: number;
+    readonly configFingerprint: string;
+    readonly readMode: ReadMode;
+    currentVersion: bigint;
+    operationQueue: Promise<void>;
+    initSeen: boolean;
+    corrupted: boolean;
+    constructor(tree: InMemoryBTree<TKey, TValue>, store: SharedTreeStore<TKey, TValue>, maxRetries: number, maxSyncMutationsPerBatch: number, configFingerprint: string, readMode: ReadMode);
+    syncUnlocked(): Promise<void>;
+    runExclusive<TResult>(operation: () => Promise<TResult>): Promise<TResult>;
+    readOp<TResult>(fn: (tree: InMemoryBTree<TKey, TValue>) => TResult): Promise<TResult>;
+    appendAndApply<TMutation extends BTreeMutation<TKey, TValue>>(evaluate: (tree: InMemoryBTree<TKey, TValue>) => TMutation | null): Promise<MutationResult<TKey, TValue, TMutation> | null>;
+    writeOp<TMutation extends BTreeMutation<TKey, TValue>>(evaluator: (tree: InMemoryBTree<TKey, TValue>) => TMutation | null): Promise<MutationResult<TKey, TValue, TMutation> | null>;
+}

package/dist/concurrency/helpers.d.ts

@@ -6,6 +6,8 @@ export type MutationResult<TKey, TValue, TMutation extends BTreeMutation<TKey, T
 } ? null : TMutation extends {
     type: 'put';
 } ? EntryId : TMutation extends {
+    type: 'putMany';
+} ? EntryId[] : TMutation extends {
     type: 'remove';
 } ? BTreeEntry<TKey, TValue> | null : TMutation extends {
     type: 'removeById';
@@ -15,8 +17,12 @@ export type MutationResult<TKey, TValue, TMutation extends BTreeMutation<TKey, T
     type: 'popFirst';
 } ? BTreeEntry<TKey, TValue> | null : TMutation extends {
     type: 'popLast';
-} ? BTreeEntry<TKey, TValue> | null : never;
-export type AnyMutationResult<TKey, TValue> = EntryId | BTreeEntry<TKey, TValue> | null;
+} ? BTreeEntry<TKey, TValue> | null : TMutation extends {
+    type: 'deleteRange';
+} ? number : TMutation extends {
+    type: 'clear';
+} ? null : never;
+export type AnyMutationResult<TKey, TValue> = EntryId | EntryId[] | BTreeEntry<TKey, TValue> | number | null;
 export declare const assertNeverMutation: (mutation: never) => never;
 export declare const validateMutationBatch: <TKey, TValue>(mutations: BTreeMutation<TKey, TValue>[], expectedConfigFingerprint?: string) => void;
 export declare const normalizeMaxRetries: (value: number | undefined) => number;

package/dist/concurrency/syncLogValidation.d.ts

@@ -0,0 +1,2 @@
+import type { SharedTreeLog } from './types.js';
+export declare const validateSyncLog: <TKey, TValue>(log: SharedTreeLog<TKey, TValue>, maxSyncMutationsPerBatch: number) => void;

package/dist/concurrency/types.d.ts

@@ -1,4 +1,4 @@
-import type { EntryId, InMemoryBTreeConfig } from '../InMemoryBTree.js';
+import type { EntryId, InMemoryBTreeConfig, RangeBounds } from '../InMemoryBTree.js';
 export type BTreeMutation<TKey, TValue> = {
     type: 'init';
     configFingerprint: string;
@@ -6,6 +6,12 @@ export type BTreeMutation<TKey, TValue> = {
     type: 'put';
     key: TKey;
     value: TValue;
+} | {
+    type: 'putMany';
+    entries: readonly {
+        key: TKey;
+        value: TValue;
+    }[];
 } | {
     type: 'remove';
     key: TKey;
@@ -20,6 +26,13 @@ export type BTreeMutation<TKey, TValue> = {
     type: 'popFirst';
 } | {
     type: 'popLast';
+} | {
+    type: 'deleteRange';
+    startKey: TKey;
+    endKey: TKey;
+    options?: RangeBounds;
+} | {
+    type: 'clear';
 };
 export interface SharedTreeLog<TKey, TValue> {
     version: bigint;

package/dist/concurrency/writeOps.d.ts

@@ -0,0 +1,48 @@
+import { InMemoryBTree, type EntryId, type RangeBounds } from '../InMemoryBTree.js';
+import type { KeyComparator, DuplicateKeyPolicy } from '../btree/types.js';
+import type { BTreeMutation } from './types.js';
+import { type AnyMutationResult } from './helpers.js';
+export declare const applyMutationLocal: <TKey, TValue>(tree: InMemoryBTree<TKey, TValue>, mutation: BTreeMutation<TKey, TValue>, onInit: () => void) => AnyMutationResult<TKey, TValue>;
+export declare const createPutEvaluator: <TKey, TValue>(duplicateKeys: DuplicateKeyPolicy, key: TKey, value: TValue) => ((tree: InMemoryBTree<TKey, TValue>) => {
+    type: "put";
+    key: TKey;
+    value: TValue;
+});
+export declare const createRemoveEvaluator: <TKey, TValue>(key: TKey) => ((tree: InMemoryBTree<TKey, TValue>) => {
+    type: "remove";
+    key: TKey;
+} | null);
+export declare const createRemoveByIdEvaluator: <TKey, TValue>(entryId: EntryId) => ((tree: InMemoryBTree<TKey, TValue>) => {
+    type: "removeById";
+    entryId: EntryId;
+} | null);
+export declare const createUpdateByIdEvaluator: <TKey, TValue>(entryId: EntryId, value: TValue) => ((tree: InMemoryBTree<TKey, TValue>) => {
+    type: "updateById";
+    entryId: EntryId;
+    value: TValue;
+} | null);
+export declare const createPopFirstEvaluator: <TKey, TValue>() => ((tree: InMemoryBTree<TKey, TValue>) => {
+    type: "popFirst";
+} | null);
+export declare const createPopLastEvaluator: <TKey, TValue>() => ((tree: InMemoryBTree<TKey, TValue>) => {
+    type: "popLast";
+} | null);
+export declare const createPutManyEvaluator: <TKey, TValue>(entries: readonly {
+    key: TKey;
+    value: TValue;
+}[], duplicateKeys: DuplicateKeyPolicy, compareKeys: KeyComparator<TKey>) => ((tree: InMemoryBTree<TKey, TValue>) => {
+    type: "putMany";
+    entries: readonly {
+        key: TKey;
+        value: TValue;
+    }[];
+});
+export declare const createDeleteRangeEvaluator: <TKey, TValue>(startKey: TKey, endKey: TKey, options: RangeBounds | undefined) => ((tree: InMemoryBTree<TKey, TValue>) => {
+    type: "deleteRange";
+    startKey: TKey;
+    endKey: TKey;
+    options?: RangeBounds;
+} | null);
+export declare const createClearEvaluator: <TKey, TValue>() => ((tree: InMemoryBTree<TKey, TValue>) => {
+    type: "clear";
+});