@frostpillar/frostpillar-btree 0.2.7 → 0.2.9

package/dist/btree/navigation.d.cts

@@ -0,0 +1,23 @@
+import { type BTreeState, type LeafNode } from './types.cjs';
+export declare const findLeafForKey: <TKey, TValue>(state: BTreeState<TKey, TValue>, userKey: TKey, sequence: number) => LeafNode<TKey, TValue>;
+export declare const lowerBoundInLeaf: <TKey, TValue>(state: BTreeState<TKey, TValue>, leaf: LeafNode<TKey, TValue>, userKey: TKey, sequence: number) => number;
+export declare const upperBoundInLeaf: <TKey, TValue>(state: BTreeState<TKey, TValue>, leaf: LeafNode<TKey, TValue>, userKey: TKey, sequence: number) => number;
+export declare const findLeafFromHint: <TKey, TValue>(state: BTreeState<TKey, TValue>, hint: LeafNode<TKey, TValue>, userKey: TKey, sequence: number) => LeafNode<TKey, TValue>;
+/** Returns shared cursor — caller must consume result before the next navigation call. */
+export declare const findFirstMatchingUserKey: <TKey, TValue>(state: BTreeState<TKey, TValue>, key: TKey) => {
+    leaf: LeafNode<TKey, TValue>;
+    index: number;
+} | null;
+/** Returns shared cursor — caller must consume result before the next navigation call. */
+export declare const findLastMatchingUserKey: <TKey, TValue>(state: BTreeState<TKey, TValue>, key: TKey) => {
+    leaf: LeafNode<TKey, TValue>;
+    index: number;
+} | null;
+export declare const hasKeyEntry: <TKey, TValue>(state: BTreeState<TKey, TValue>, key: TKey) => boolean;
+export declare const findNextHigherKey: <TKey, TValue>(state: BTreeState<TKey, TValue>, key: TKey) => TKey | null;
+export declare const findNextLowerKey: <TKey, TValue>(state: BTreeState<TKey, TValue>, key: TKey) => TKey | null;
+/** Returns shared cursor — caller must consume result before the next navigation call. */
+export declare const findPairOrNextLower: <TKey, TValue>(state: BTreeState<TKey, TValue>, key: TKey) => {
+    leaf: LeafNode<TKey, TValue>;
+    index: number;
+} | null;

package/dist/btree/node-ops.d.cts

@@ -0,0 +1,15 @@
+import type { BranchNode, BTreeNode, LeafEntry, LeafNode, NodeKey } from './types.cjs';
+export declare const createLeafNode: <TKey, TValue>(entries: LeafEntry<TKey, TValue>[], parent: BranchNode<TKey, TValue> | null) => LeafNode<TKey, TValue>;
+export declare const createBranchNode: <TKey, TValue>(children: BTreeNode<TKey, TValue>[], parent: BranchNode<TKey, TValue> | null) => BranchNode<TKey, TValue>;
+export declare const leafEntryCount: <TKey, TValue>(leaf: LeafNode<TKey, TValue>) => number;
+export declare const leafEntryAt: <TKey, TValue>(leaf: LeafNode<TKey, TValue>, i: number) => LeafEntry<TKey, TValue>;
+export declare const leafShiftEntry: <TKey, TValue>(leaf: LeafNode<TKey, TValue>) => LeafEntry<TKey, TValue> | undefined;
+export declare const leafPopEntry: <TKey, TValue>(leaf: LeafNode<TKey, TValue>) => LeafEntry<TKey, TValue> | undefined;
+export declare const leafUnshiftEntry: <TKey, TValue>(leaf: LeafNode<TKey, TValue>, entry: LeafEntry<TKey, TValue>) => void;
+export declare const leafRemoveAt: <TKey, TValue>(leaf: LeafNode<TKey, TValue>, logicalIndex: number) => void;
+export declare const leafInsertAt: <TKey, TValue>(leaf: LeafNode<TKey, TValue>, logicalIndex: number, entry: LeafEntry<TKey, TValue>) => void;
+export declare const leafCompact: <TKey, TValue>(leaf: LeafNode<TKey, TValue>) => void;
+export declare const branchCompact: <TKey, TValue>(branch: BranchNode<TKey, TValue>) => void;
+export declare const branchChildCount: <TKey, TValue>(branch: BranchNode<TKey, TValue>) => number;
+export declare const branchInsertAt: <TKey, TValue>(branch: BranchNode<TKey, TValue>, logicalIndex: number, child: BTreeNode<TKey, TValue>, key: NodeKey<TKey>) => void;
+export declare const branchRemoveAt: <TKey, TValue>(branch: BranchNode<TKey, TValue>, physIndex: number) => void;

package/dist/btree/rangeQuery.d.cts

@@ -0,0 +1,7 @@
+import { type BTreeEntry, type BTreeState, type RangeBounds } from './types.cjs';
+export declare function isEmptyRange<TKey>(compare: (a: TKey, b: TKey) => number, startKey: TKey, endKey: TKey, options?: RangeBounds): boolean;
+export declare const countRangeEntries: <TKey, TValue>(state: BTreeState<TKey, TValue>, startKey: TKey, endKey: TKey, options?: RangeBounds) => number;
+/** Single-pass range query that produces public entries (via freezeEntry) inline. */
+export declare const rangeQueryPublicEntries: <TKey, TValue>(state: BTreeState<TKey, TValue>, startKey: TKey, endKey: TKey, options?: RangeBounds) => BTreeEntry<TKey, TValue>[];
+/** Streaming range iteration — invokes callback for each entry without array allocation. */
+export declare const forEachRangeEntries: <TKey, TValue>(state: BTreeState<TKey, TValue>, startKey: TKey, endKey: TKey, callback: (entry: BTreeEntry<TKey, TValue>) => void, options?: RangeBounds) => void;

package/dist/btree/rebalance-branch.d.cts

@@ -0,0 +1,4 @@
+import { type BTreeNode, type BTreeState, type BranchNode } from './types.cjs';
+export declare const updateMinKeyInAncestors: <TKey, TValue>(node: BTreeNode<TKey, TValue>) => void;
+export declare const removeChildFromBranch: <TKey, TValue>(branch: BranchNode<TKey, TValue>, childIndex: number) => void;
+export declare const rebalanceAfterBranchRemoval: <TKey, TValue>(state: BTreeState<TKey, TValue>, branch: BranchNode<TKey, TValue>) => void;

package/dist/btree/rebalance.d.cts

@@ -0,0 +1,7 @@
+import { type BTreeState, type LeafNode } from './types.cjs';
+import { updateMinKeyInAncestors } from './rebalance-branch.cjs';
+export { updateMinKeyInAncestors };
+/** Applies the lazy divisor to a minimum-occupancy value. */
+export declare const applyLazyThreshold: (min: number) => number;
+export declare const leafRebalanceThreshold: <TKey, TValue>(state: BTreeState<TKey, TValue>) => number;
+export declare const rebalanceAfterLeafRemoval: <TKey, TValue>(state: BTreeState<TKey, TValue>, leaf: LeafNode<TKey, TValue>) => void;

package/dist/btree/serialization.d.cts

@@ -0,0 +1,18 @@
+import { type BTreeState, type DeleteRebalancePolicy, type DuplicateKeyPolicy, type InMemoryBTreeConfig, type KeyComparator } from './types.cjs';
+export interface BTreeJSON<TKey, TValue> {
+    version: number;
+    config: {
+        maxLeafEntries: number;
+        maxBranchChildren: number;
+        duplicateKeys: DuplicateKeyPolicy;
+        enableEntryIdLookup: boolean;
+        autoScale: boolean;
+        deleteRebalancePolicy?: DeleteRebalancePolicy;
+    };
+    entries: [TKey, TValue][];
+}
+export declare const buildConfigFromState: <TKey, TValue>(state: BTreeState<TKey, TValue>) => InMemoryBTreeConfig<TKey>;
+export declare const serializeToJSON: <TKey, TValue>(state: BTreeState<TKey, TValue>) => BTreeJSON<TKey, TValue>;
+export declare const validateBTreeJSON: <TKey, TValue>(json: BTreeJSON<TKey, TValue>) => void;
+export declare const validateBTreeJSONSortOrder: <TKey, TValue>(json: BTreeJSON<TKey, TValue>, compareKeys: KeyComparator<TKey>) => void;
+export declare const buildConfigFromJSON: <TKey>(json: BTreeJSON<TKey, unknown>, compareKeys: KeyComparator<TKey>) => InMemoryBTreeConfig<TKey>;

package/dist/btree/split.d.cts

@@ -0,0 +1,3 @@
+import { type BTreeState, type BranchNode, type LeafNode } from './types.cjs';
+export declare const splitLeaf: <TKey, TValue>(state: BTreeState<TKey, TValue>, leaf: LeafNode<TKey, TValue>) => void;
+export declare const splitBranch: <TKey, TValue>(state: BTreeState<TKey, TValue>, branch: BranchNode<TKey, TValue>) => void;

package/dist/btree/stats.d.cts

@@ -0,0 +1,2 @@
+import { type BTreeState, type BTreeStats } from './types.cjs';
+export declare const getStats: <TKey, TValue>(state: BTreeState<TKey, TValue>) => BTreeStats;

package/dist/btree/traversal.d.cts

@@ -0,0 +1,7 @@
+import { type BTreeEntry, type BTreeState } from './types.cjs';
+/** Collect all entries into a pre-allocated array, frozen for safe external use. */
+export declare const snapshotEntries: <TKey, TValue>(state: BTreeState<TKey, TValue>) => BTreeEntry<TKey, TValue>[];
+/** Collect all internal entries (no freeze) for internal use (clone, serialize). */
+export declare const collectInternalEntries: <TKey, TValue>(state: BTreeState<TKey, TValue>) => BTreeEntry<TKey, TValue>[];
+/** Iterate all entries, invoking callback with frozen entries. */
+export declare const forEachEntry: <TKey, TValue>(state: BTreeState<TKey, TValue>, callback: (entry: BTreeEntry<TKey, TValue>) => void, thisArg?: unknown) => void;

package/dist/btree/types.d.cts

@@ -0,0 +1,110 @@
+export declare const DEFAULT_MAX_LEAF_ENTRIES = 64;
+export declare const DEFAULT_MAX_BRANCH_CHILDREN = 64;
+export declare const MIN_NODE_CAPACITY = 3;
+export declare const MAX_NODE_CAPACITY = 16384;
+export declare const NODE_LEAF: 0;
+export declare const NODE_BRANCH: 1;
+export type KeyComparator<TKey> = (left: TKey, right: TKey) => number;
+export type DuplicateKeyPolicy = 'allow' | 'reject' | 'replace';
+export type DeleteRebalancePolicy = 'standard' | 'lazy';
+/**
+ * Defines the inclusivity of the lower and upper bounds for a key range scan.
+ * Both bounds default to `'inclusive'` when omitted.
+ */
+export interface RangeBounds {
+    /** Lower bound type. Defaults to `'inclusive'` when omitted. */
+    lowerBound?: 'inclusive' | 'exclusive';
+    /** Upper bound type. Defaults to `'inclusive'` when omitted. */
+    upperBound?: 'inclusive' | 'exclusive';
+}
+export declare const normalizeDuplicateKeyPolicy: (value: DuplicateKeyPolicy | undefined) => DuplicateKeyPolicy;
+export declare const normalizeDeleteRebalancePolicy: (value: DeleteRebalancePolicy | undefined) => DeleteRebalancePolicy;
+export type EntryId = number & {
+    readonly __brand: 'EntryId';
+};
+export interface BTreeEntry<TKey, TValue> {
+    readonly entryId: EntryId;
+    readonly key: TKey;
+    readonly value: TValue;
+}
+export interface NodeKey<TKey> {
+    key: TKey;
+    sequence: number;
+}
+/** Internal mutable entry stored in leaf nodes. */
+export interface LeafEntry<TKey, TValue> {
+    entryId: EntryId;
+    key: TKey;
+    value: TValue;
+}
+/**
+ * Freezes and returns an internal entry for safe exposure via the public API.
+ * Idempotent: re-freezing an already-frozen object is a no-op in V8.
+ * All entries are frozen at creation via createEntry, so this is a zero-allocation cast.
+ */
+export declare const freezeEntry: <TKey, TValue>(entry: LeafEntry<TKey, TValue>) => BTreeEntry<TKey, TValue>;
+/**
+ * Creates a frozen LeafEntry with a canonical property order.
+ * All entry creation MUST go through this function to guarantee a single
+ * V8 hidden class across all entries in the tree.
+ */
+export declare const createEntry: <TKey, TValue>(key: TKey, entryId: EntryId, value: TValue) => LeafEntry<TKey, TValue>;
+export interface LeafNode<TKey, TValue> {
+    kind: typeof NODE_LEAF;
+    entries: LeafEntry<TKey, TValue>[];
+    entryOffset: number;
+    parent: BranchNode<TKey, TValue> | null;
+    indexInParent: number;
+    prev: LeafNode<TKey, TValue> | null;
+    next: LeafNode<TKey, TValue> | null;
+}
+export interface BranchNode<TKey, TValue> {
+    kind: typeof NODE_BRANCH;
+    children: BTreeNode<TKey, TValue>[];
+    keys: NodeKey<TKey>[];
+    childOffset: number;
+    parent: BranchNode<TKey, TValue> | null;
+    indexInParent: number;
+}
+export type BTreeNode<TKey, TValue> = LeafNode<TKey, TValue> | BranchNode<TKey, TValue>;
+export interface BTreeState<TKey, TValue> {
+    compareKeys: KeyComparator<TKey>;
+    maxLeafEntries: number;
+    maxBranchChildren: number;
+    duplicateKeys: DuplicateKeyPolicy;
+    root: BTreeNode<TKey, TValue>;
+    leftmostLeaf: LeafNode<TKey, TValue>;
+    rightmostLeaf: LeafNode<TKey, TValue>;
+    entryCount: number;
+    nextSequence: number;
+    minLeafEntries: number;
+    minBranchChildren: number;
+    entryKeys: Map<EntryId, TKey> | null;
+    autoScale: boolean;
+    deleteRebalancePolicy: DeleteRebalancePolicy;
+    _nextAutoScaleThreshold: number;
+    /** @internal Shared return object for navigation functions — never store a reference across calls. */
+    _cursor: {
+        leaf: LeafNode<TKey, TValue>;
+        index: number;
+    };
+}
+export interface InMemoryBTreeConfig<TKey> {
+    compareKeys: KeyComparator<TKey>;
+    maxLeafEntries?: number;
+    maxBranchChildren?: number;
+    duplicateKeys?: DuplicateKeyPolicy;
+    enableEntryIdLookup?: boolean;
+    autoScale?: boolean;
+    deleteRebalancePolicy?: DeleteRebalancePolicy;
+}
+export interface BTreeStats {
+    height: number;
+    leafCount: number;
+    branchCount: number;
+    entryCount: number;
+}
+export declare const isLeafNode: <TKey, TValue>(node: BTreeNode<TKey, TValue>) => node is LeafNode<TKey, TValue>;
+export declare const writeMinKeyTo: <TKey, TValue>(node: BTreeNode<TKey, TValue>, target: NodeKey<TKey>) => boolean;
+export declare const normalizeNodeCapacity: (value: number | undefined, field: string, defaultValue: number) => number;
+export { createLeafNode, createBranchNode, leafEntryCount, leafEntryAt, leafShiftEntry, leafPopEntry, leafUnshiftEntry, leafRemoveAt, leafInsertAt, leafCompact, branchCompact, branchChildCount, branchInsertAt, branchRemoveAt, } from './node-ops.cjs';

package/dist/{chunk-UGGWGP4E.js → chunk-OFXDCKLC.js}

@@ -806,8 +806,10 @@ var tryBorrowFromLeafSibling = (state, leaf, parent, leafIndex, leftSibling, rig
     const borrowed = leafShiftEntry(rightSibling);
     if (borrowed === void 0)
       throw new BTreeInvariantError("right leaf borrow failed");
+    const leafWasEmpty = leafEntryCount(leaf) === 0;
     leaf.entries.push(borrowed);
     writeMinKeyTo(rightSibling, parent.keys[leafIndex + 1]);
+    if (leafWasEmpty) updateMinKeyInAncestors(leaf);
     return true;
   }
   if (leftSibling !== null && leafEntryCount(leftSibling) > state.minLeafEntries) {
@@ -830,8 +832,10 @@ var mergeLeafWithSibling = (state, leaf, parent, leafIndex, leftSibling, rightSi
     return;
   }
   if (rightSibling !== null) {
+    const leafWasEmpty = leafEntryCount(leaf) === 0;
     mergeLeafEntries(leaf, rightSibling);
     detachLeafFromChain(state, rightSibling);
+    if (leafWasEmpty) updateMinKeyInAncestors(leaf);
     removeChildFromBranch(parent, leafIndex + 1);
     rebalanceAfterBranchRemoval(state, parent);
     return;
@@ -902,9 +906,6 @@ var spliceLeafAndRebalance = (state, leaf, idx, removeCount) => {
       break;
     safetyGuard -= 1;
   }
-  if (leafEmptied && leafEntryCount(leaf) > 0 && leaf.parent !== null && leaf.parent.children[leaf.indexInParent] === leaf) {
-    updateMinKeyInAncestors(leaf);
-  }
   return countAfterSplice;
 };
 var isLeafStillValid = (state, leaf) => leaf.parent === null ? leaf === state.root : leaf.parent.children[leaf.indexInParent] === leaf;

package/dist/concurrency/ConcurrentInMemoryBTree.d.cts

@@ -0,0 +1,49 @@
+import { InMemoryBTree, type BTreeEntry, type BTreeJSON, type BTreeStats, type EntryId, type RangeBounds } from '../InMemoryBTree.cjs';
+import type { KeyComparator } from '../btree/types.cjs';
+import type { ConcurrentInMemoryBTreeConfig } from './types.cjs';
+export declare class ConcurrentInMemoryBTree<TKey, TValue> {
+    private readonly coord;
+    private readonly compareKeys;
+    private readonly duplicateKeys;
+    constructor(config: ConcurrentInMemoryBTreeConfig<TKey, TValue>);
+    sync(): Promise<void>;
+    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>;
+    findLast(key: TKey): Promise<BTreeEntry<TKey, TValue> | null>;
+    range(startKey: TKey, endKey: TKey, options?: RangeBounds): Promise<BTreeEntry<TKey, TValue>[]>;
+    snapshot(): Promise<BTreeEntry<TKey, TValue>[]>;
+    size(): Promise<number>;
+    assertInvariants(): Promise<void>;
+    getStats(): Promise<BTreeStats>;
+    peekFirst(): Promise<BTreeEntry<TKey, TValue> | null>;
+    peekLast(): 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.cts

@@ -0,0 +1,21 @@
+import { InMemoryBTree } from '../InMemoryBTree.cjs';
+import type { BTreeMutation, ReadMode, SharedTreeStore } from './types.cjs';
+import { type MutationResult } from './helpers.cjs';
+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.cts

@@ -0,0 +1,34 @@
+import type { BTreeMutation, ConcurrentInMemoryBTreeConfig, ReadMode } from './types.cjs';
+import type { BTreeEntry, EntryId } from '../InMemoryBTree.cjs';
+export declare const computeConfigFingerprint: <TKey>(config: ConcurrentInMemoryBTreeConfig<TKey, unknown>) => string;
+export type MutationResult<TKey, TValue, TMutation extends BTreeMutation<TKey, TValue>> = TMutation extends {
+    type: 'init';
+} ? null : TMutation extends {
+    type: 'put';
+} ? EntryId : TMutation extends {
+    type: 'putMany';
+} ? EntryId[] : TMutation extends {
+    type: 'remove';
+} ? BTreeEntry<TKey, TValue> | null : TMutation extends {
+    type: 'removeById';
+} ? BTreeEntry<TKey, TValue> | null : TMutation extends {
+    type: 'updateById';
+} ? BTreeEntry<TKey, TValue> | null : TMutation extends {
+    type: 'popFirst';
+} ? BTreeEntry<TKey, TValue> | null : TMutation extends {
+    type: 'popLast';
+} ? 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;
+export declare const normalizeMaxSyncMutationsPerBatch: (value: number | undefined) => number;
+export declare const normalizeReadMode: (value: ReadMode | undefined) => ReadMode;
+export declare function assertAppendVersionContract(expectedVersion: bigint, appendResult: unknown): asserts appendResult is {
+    applied: boolean;
+    version: bigint;
+};

package/dist/concurrency/index.d.cts

@@ -0,0 +1,2 @@
+export { ConcurrentInMemoryBTree } from './ConcurrentInMemoryBTree.cjs';
+export type { BTreeMutation, ConcurrentInMemoryBTreeConfig, ReadMode, SharedTreeLog, SharedTreeStore, } from './types.cjs';

package/dist/concurrency/syncLogValidation.d.cts

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

package/dist/concurrency/types.d.cts

@@ -0,0 +1,54 @@
+import type { EntryId, InMemoryBTreeConfig, RangeBounds } from '../InMemoryBTree.cjs';
+export type BTreeMutation<TKey, TValue> = {
+    type: 'init';
+    configFingerprint: string;
+} | {
+    type: 'put';
+    key: TKey;
+    value: TValue;
+} | {
+    type: 'putMany';
+    entries: readonly {
+        key: TKey;
+        value: TValue;
+    }[];
+} | {
+    type: 'remove';
+    key: TKey;
+} | {
+    type: 'removeById';
+    entryId: EntryId;
+} | {
+    type: 'updateById';
+    entryId: EntryId;
+    value: TValue;
+} | {
+    type: 'popFirst';
+} | {
+    type: 'popLast';
+} | {
+    type: 'deleteRange';
+    startKey: TKey;
+    endKey: TKey;
+    options?: RangeBounds;
+} | {
+    type: 'clear';
+};
+export interface SharedTreeLog<TKey, TValue> {
+    version: bigint;
+    mutations: BTreeMutation<TKey, TValue>[];
+}
+export interface SharedTreeStore<TKey, TValue> {
+    getLogEntriesSince(version: bigint): Promise<SharedTreeLog<TKey, TValue>>;
+    append(expectedVersion: bigint, mutations: BTreeMutation<TKey, TValue>[]): Promise<{
+        applied: boolean;
+        version: bigint;
+    }>;
+}
+export type ReadMode = 'strong' | 'local';
+export interface ConcurrentInMemoryBTreeConfig<TKey, TValue> extends InMemoryBTreeConfig<TKey> {
+    store: SharedTreeStore<TKey, TValue>;
+    maxRetries?: number;
+    maxSyncMutationsPerBatch?: number;
+    readMode?: ReadMode;
+}

package/dist/concurrency/writeOps.d.cts

@@ -0,0 +1,48 @@
+import { InMemoryBTree, type EntryId, type RangeBounds } from '../InMemoryBTree.cjs';
+import type { KeyComparator, DuplicateKeyPolicy } from '../btree/types.cjs';
+import type { BTreeMutation } from './types.cjs';
+import { type AnyMutationResult } from './helpers.cjs';
+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";
+});

package/dist/core.cjs

@@ -827,8 +827,10 @@ var tryBorrowFromLeafSibling = (state, leaf, parent, leafIndex, leftSibling, rig
     const borrowed = leafShiftEntry(rightSibling);
     if (borrowed === void 0)
       throw new BTreeInvariantError("right leaf borrow failed");
+    const leafWasEmpty = leafEntryCount(leaf) === 0;
     leaf.entries.push(borrowed);
     writeMinKeyTo(rightSibling, parent.keys[leafIndex + 1]);
+    if (leafWasEmpty) updateMinKeyInAncestors(leaf);
     return true;
   }
   if (leftSibling !== null && leafEntryCount(leftSibling) > state.minLeafEntries) {
@@ -851,8 +853,10 @@ var mergeLeafWithSibling = (state, leaf, parent, leafIndex, leftSibling, rightSi
     return;
   }
   if (rightSibling !== null) {
+    const leafWasEmpty = leafEntryCount(leaf) === 0;
     mergeLeafEntries(leaf, rightSibling);
     detachLeafFromChain(state, rightSibling);
+    if (leafWasEmpty) updateMinKeyInAncestors(leaf);
     removeChildFromBranch(parent, leafIndex + 1);
     rebalanceAfterBranchRemoval(state, parent);
     return;
@@ -923,9 +927,6 @@ var spliceLeafAndRebalance = (state, leaf, idx, removeCount) => {
       break;
     safetyGuard -= 1;
   }
-  if (leafEmptied && leafEntryCount(leaf) > 0 && leaf.parent !== null && leaf.parent.children[leaf.indexInParent] === leaf) {
-    updateMinKeyInAncestors(leaf);
-  }
   return countAfterSplice;
 };
 var isLeafStillValid = (state, leaf) => leaf.parent === null ? leaf === state.root : leaf.parent.children[leaf.indexInParent] === leaf;

package/dist/core.d.cts

@@ -0,0 +1,4 @@
+export { InMemoryBTree } from './InMemoryBTree.cjs';
+export type { BTreeEntry, BTreeJSON, BTreeStats, DeleteRebalancePolicy, DuplicateKeyPolicy, EntryId, InMemoryBTreeConfig, RangeBounds, } from './InMemoryBTree.cjs';
+export { BTreeInvariantError, BTreeValidationError } from './errors.cjs';
+export type { KeyComparator } from './btree/types.cjs';

package/dist/core.js

@@ -2,7 +2,7 @@ import {
   BTreeInvariantError,
   BTreeValidationError,
   InMemoryBTree
-} from "./chunk-UGGWGP4E.js";
+} from "./chunk-OFXDCKLC.js";
 export {
   BTreeInvariantError,
   BTreeValidationError,

package/dist/errors.d.cts

@@ -0,0 +1,12 @@
+/** Thrown when a caller supplies invalid input, such as a duplicate key, sequence overflow, or malformed configuration. */
+export declare class BTreeValidationError extends Error {
+    constructor(message: string);
+}
+/** Thrown when an internal tree invariant is violated, indicating a bug in the library rather than invalid caller input. */
+export declare class BTreeInvariantError extends Error {
+    constructor(message: string);
+}
+/** Thrown when the concurrent store contract is violated or a mutation batch is malformed during optimistic concurrency operations. */
+export declare class BTreeConcurrencyError extends Error {
+    constructor(message: string);
+}