@frostpillar/frostpillar-btree 0.2.5 → 0.2.7

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

@@ -21,54 +21,10 @@ var BTreeConcurrencyError = class extends Error {
   }
 };
 
-// src/btree/types.ts
-var DEFAULT_MAX_LEAF_ENTRIES = 64;
-var DEFAULT_MAX_BRANCH_CHILDREN = 64;
-var MIN_NODE_CAPACITY = 3;
-var MAX_NODE_CAPACITY = 16384;
-var NODE_LEAF = 0;
-var NODE_BRANCH = 1;
-var normalizeDuplicateKeyPolicy = (value) => {
-  if (value === void 0) {
-    return "replace";
-  }
-  if (value !== "allow" && value !== "reject" && value !== "replace") {
-    throw new BTreeValidationError(
-      `Invalid duplicateKeys option.`
-    );
-  }
-  return value;
-};
-var isLeafNode = (node) => {
-  return node.kind === NODE_LEAF;
-};
-var writeMinKeyTo = (node, target) => {
-  if (node.kind === NODE_LEAF) {
-    if (node.entryOffset >= node.entries.length) return false;
-    const e = node.entries[node.entryOffset];
-    target.key = e.key;
-    target.sequence = e.entryId;
-    return true;
-  }
-  if (node.childOffset >= node.keys.length) return false;
-  target.key = node.keys[node.childOffset].key;
-  target.sequence = node.keys[node.childOffset].sequence;
-  return true;
-};
-var normalizeNodeCapacity = (value, field, defaultValue) => {
-  if (value === void 0) {
-    return defaultValue;
-  }
-  if (!Number.isInteger(value) || value < MIN_NODE_CAPACITY || value > MAX_NODE_CAPACITY) {
-    throw new BTreeValidationError(
-      `${field}: integer ${MIN_NODE_CAPACITY}\u2013${MAX_NODE_CAPACITY} required.`
-    );
-  }
-  return value;
-};
+// src/btree/node-ops.ts
 var createLeafNode = (entries, parent) => {
   return {
-    kind: NODE_LEAF,
+    kind: 0,
     entries,
     entryOffset: 0,
     parent,
@@ -80,7 +36,7 @@ var createLeafNode = (entries, parent) => {
 var createBranchNode = (children, parent) => {
   const keys = [];
   const branch = {
-    kind: NODE_BRANCH,
+    kind: 1,
     children,
     keys,
     childOffset: 0,
@@ -91,11 +47,12 @@ var createBranchNode = (children, parent) => {
     const child = children[i];
     child.parent = branch;
     child.indexInParent = i;
-    const target = { key: void 0, sequence: 0 };
+    const target = {
+      key: void 0,
+      sequence: 0
+    };
     if (!writeMinKeyTo(child, target)) {
-      throw new BTreeInvariantError(
-        "branch child has no min key"
-      );
+      throw new BTreeInvariantError("branch child has no min key");
     }
     keys.push(target);
   }
@@ -149,7 +106,14 @@ var leafInsertAt = (leaf, logicalIndex, entry) => {
     leaf.entryOffset -= 1;
     leaf.entries[phys - 1] = entry;
   } else {
-    leaf.entries.splice(phys, 0, entry);
+    const len = leaf.entries.length;
+    if (phys >= len) {
+      leaf.entries.push(entry);
+    } else {
+      leaf.entries.push(leaf.entries[len - 1]);
+      leaf.entries.copyWithin(phys + 1, phys, len);
+      leaf.entries[phys] = entry;
+    }
   }
 };
 var leafCompact = (leaf) => {
@@ -178,7 +142,11 @@ var branchInsertAt = (branch, logicalIndex, child, key) => {
   const phys = branch.childOffset + logicalIndex;
   const count = branch.children.length - branch.childOffset;
   if (branch.childOffset > 0 && logicalIndex < count >>> 1) {
-    branch.children.copyWithin(branch.childOffset - 1, branch.childOffset, phys);
+    branch.children.copyWithin(
+      branch.childOffset - 1,
+      branch.childOffset,
+      phys
+    );
     branch.keys.copyWithin(branch.childOffset - 1, branch.childOffset, phys);
     branch.childOffset -= 1;
     branch.children[phys - 1] = child;
@@ -199,8 +167,16 @@ var branchRemoveAt = (branch, physIndex) => {
   const logicalIndex = physIndex - branch.childOffset;
   const count = branch.children.length - branch.childOffset;
   if (logicalIndex < count - 1 - logicalIndex) {
-    branch.children.copyWithin(branch.childOffset + 1, branch.childOffset, physIndex);
-    branch.keys.copyWithin(branch.childOffset + 1, branch.childOffset, physIndex);
+    branch.children.copyWithin(
+      branch.childOffset + 1,
+      branch.childOffset,
+      physIndex
+    );
+    branch.keys.copyWithin(
+      branch.childOffset + 1,
+      branch.childOffset,
+      physIndex
+    );
     branch.childOffset += 1;
     for (let i = branch.childOffset; i <= physIndex; i += 1) {
       branch.children[i].indexInParent = i;
@@ -219,6 +195,60 @@ var branchRemoveAt = (branch, physIndex) => {
   }
 };
 
+// src/btree/types.ts
+var DEFAULT_MAX_LEAF_ENTRIES = 64;
+var DEFAULT_MAX_BRANCH_CHILDREN = 64;
+var MIN_NODE_CAPACITY = 3;
+var MAX_NODE_CAPACITY = 16384;
+var NODE_LEAF = 0;
+var normalizeDuplicateKeyPolicy = (value) => {
+  if (value === void 0) {
+    return "replace";
+  }
+  if (value !== "allow" && value !== "reject" && value !== "replace") {
+    throw new BTreeValidationError(`Invalid duplicateKeys option.`);
+  }
+  return value;
+};
+var normalizeDeleteRebalancePolicy = (value) => {
+  if (value === void 0) {
+    return "standard";
+  }
+  if (value !== "standard" && value !== "lazy") {
+    throw new BTreeValidationError(`Invalid deleteRebalancePolicy option.`);
+  }
+  return value;
+};
+var freezeEntry = (entry) => Object.freeze(entry);
+var createEntry = (key, entryId, value) => Object.freeze({ key, entryId, value });
+var isLeafNode = (node) => {
+  return node.kind === NODE_LEAF;
+};
+var writeMinKeyTo = (node, target) => {
+  if (node.kind === NODE_LEAF) {
+    if (node.entryOffset >= node.entries.length) return false;
+    const e = node.entries[node.entryOffset];
+    target.key = e.key;
+    target.sequence = e.entryId;
+    return true;
+  }
+  if (node.childOffset >= node.keys.length) return false;
+  target.key = node.keys[node.childOffset].key;
+  target.sequence = node.keys[node.childOffset].sequence;
+  return true;
+};
+var normalizeNodeCapacity = (value, field, defaultValue) => {
+  if (value === void 0) {
+    return defaultValue;
+  }
+  if (!Number.isInteger(value) || value < MIN_NODE_CAPACITY || value > MAX_NODE_CAPACITY) {
+    throw new BTreeValidationError(
+      `${field}: integer ${MIN_NODE_CAPACITY}\u2013${MAX_NODE_CAPACITY} required.`
+    );
+  }
+  return value;
+};
+
 // src/btree/navigation.ts
 var selectBranchChild = (compare, branch, userKey, sequence) => {
   const off = branch.childOffset;
@@ -232,7 +262,7 @@ var selectBranchChild = (compare, branch, userKey, sequence) => {
     const mid = lower + upper >>> 1;
     const k = branch.keys[mid];
     const cmp = compare(k.key, userKey);
-    if ((cmp !== 0 ? cmp : k.sequence - sequence) <= 0) {
+    if ((cmp !== 0 ? cmp : k.sequence < sequence ? -1 : k.sequence > sequence ? 1 : 0) <= 0) {
       selectedIndex = mid;
       lower = mid + 1;
     } else {
@@ -257,7 +287,7 @@ var lowerBoundInLeaf = (state, leaf, userKey, sequence) => {
     const mid = lower + upper >>> 1;
     const e = leaf.entries[mid];
     const cmp = compare(e.key, userKey);
-    if ((cmp !== 0 ? cmp : e.entryId - sequence) < 0) {
+    if ((cmp !== 0 ? cmp : e.entryId < sequence ? -1 : e.entryId > sequence ? 1 : 0) < 0) {
       lower = mid + 1;
     } else {
       upper = mid;
@@ -273,7 +303,7 @@ var upperBoundInLeaf = (state, leaf, userKey, sequence) => {
     const mid = lower + upper >>> 1;
     const e = leaf.entries[mid];
     const cmp = compare(e.key, userKey);
-    if ((cmp !== 0 ? cmp : e.entryId - sequence) <= 0) {
+    if ((cmp !== 0 ? cmp : e.entryId < sequence ? -1 : e.entryId > sequence ? 1 : 0) <= 0) {
       lower = mid + 1;
     } else {
       upper = mid;
@@ -340,7 +370,11 @@ var hasKeyEntry = (state, key) => {
 var findNextHigherKey = (state, key) => {
   if (state.entryCount === 0) return null;
   const compare = state.compareKeys;
-  let leaf = findLeafForKey(state, key, Number.MAX_SAFE_INTEGER);
+  let leaf = findLeafForKey(
+    state,
+    key,
+    Number.MAX_SAFE_INTEGER
+  );
   let idx = upperBoundInLeaf(state, leaf, key, Number.MAX_SAFE_INTEGER);
   while (leaf !== null) {
     if (idx < leafEntryCount(leaf)) {
@@ -410,7 +444,175 @@ var findPairOrNextLower = (state, key) => {
   return null;
 };
 
-// src/btree/rebalance.ts
+// src/btree/rangeQuery.ts
+function isEmptyRange(compare, startKey, endKey, options) {
+  const cmp = compare(startKey, endKey);
+  if (cmp > 0) return true;
+  const lowerExclusive = options?.lowerBound === "exclusive";
+  const upperExclusive = options?.upperBound === "exclusive";
+  return lowerExclusive && upperExclusive && cmp === 0;
+}
+var initRangeCursor = (state, startKey, endKey, options) => {
+  if (state.entryCount === 0) return null;
+  const compare = state.compareKeys;
+  if (isEmptyRange(compare, startKey, endKey, options)) return null;
+  const lowerExclusive = options?.lowerBound === "exclusive";
+  const upperExclusive = options?.upperBound === "exclusive";
+  const startSeq = lowerExclusive ? Number.MAX_SAFE_INTEGER : 0;
+  const leaf = findLeafForKey(state, startKey, startSeq);
+  const index = lowerExclusive ? upperBoundInLeaf(state, leaf, startKey, Number.MAX_SAFE_INTEGER) : lowerBoundInLeaf(state, leaf, startKey, 0);
+  return { leaf, index, compare, upperExclusive };
+};
+var countRangeEntries = (state, startKey, endKey, options) => {
+  const cursor = initRangeCursor(state, startKey, endKey, options);
+  if (cursor === null) return 0;
+  let cursorLeaf = cursor.leaf;
+  let cursorIndex = cursor.index;
+  const { compare, upperExclusive } = cursor;
+  let count = 0;
+  while (cursorLeaf !== null) {
+    const leafCount = leafEntryCount(cursorLeaf);
+    if (cursorIndex >= leafCount) {
+      cursorLeaf = cursorLeaf.next;
+      cursorIndex = 0;
+      continue;
+    }
+    const lastKey = leafEntryAt(cursorLeaf, leafCount - 1).key;
+    if (isLastEntryInRange(lastKey, endKey, compare, upperExclusive)) {
+      count += leafCount - cursorIndex;
+      cursorLeaf = cursorLeaf.next;
+      cursorIndex = 0;
+      continue;
+    }
+    count += findBoundaryEnd(state, cursorLeaf, endKey, upperExclusive, leafCount) - cursorIndex;
+    return count;
+  }
+  return count;
+};
+var isLastEntryInRange = (lastKey, endKey, compare, upperExclusive) => {
+  const cmp = compare(lastKey, endKey);
+  return upperExclusive ? cmp < 0 : cmp <= 0;
+};
+var findBoundaryEnd = (state, leaf, endKey, upperExclusive, leafCount) => {
+  const endSeq = upperExclusive ? 0 : Number.MAX_SAFE_INTEGER;
+  const endBound = upperExclusive ? lowerBoundInLeaf(state, leaf, endKey, endSeq) : upperBoundInLeaf(state, leaf, endKey, endSeq);
+  return endBound < leafCount ? endBound : leafCount;
+};
+var RANGE_PREALLOC_THRESHOLD = 200;
+var allocateRangeOutput = (state, cursor, startKey, endKey, options) => {
+  const firstLeafCount = leafEntryCount(cursor.leaf);
+  const firstLeafRemainder = firstLeafCount - cursor.index;
+  if (firstLeafRemainder >= RANGE_PREALLOC_THRESHOLD && cursor.leaf.next !== null) {
+    const lastKey = leafEntryAt(cursor.leaf, firstLeafCount - 1).key;
+    if (isLastEntryInRange(lastKey, endKey, cursor.compare, cursor.upperExclusive)) {
+      return new Array(
+        countRangeEntries(state, startKey, endKey, options)
+      );
+    }
+  }
+  return [];
+};
+var appendLeafSlicePublic = (leaf, from, to, output, useIndexed, writeIdx) => {
+  if (useIndexed) {
+    for (let i = from; i < to; i += 1) {
+      output[writeIdx++] = freezeEntry(leafEntryAt(leaf, i));
+    }
+  } else {
+    for (let i = from; i < to; i += 1) {
+      output.push(freezeEntry(leafEntryAt(leaf, i)));
+    }
+  }
+  return writeIdx;
+};
+var collectPublicEntries = (state, cursor, endKey, output) => {
+  const { compare, upperExclusive } = cursor;
+  let cursorLeaf = cursor.leaf;
+  let cursorIndex = cursor.index;
+  let writeIdx = 0;
+  const useIndexed = output.length > 0;
+  while (cursorLeaf !== null) {
+    const leafCount = leafEntryCount(cursorLeaf);
+    if (cursorIndex >= leafCount) {
+      cursorLeaf = cursorLeaf.next;
+      cursorIndex = 0;
+      continue;
+    }
+    const lastKey = leafEntryAt(cursorLeaf, leafCount - 1).key;
+    if (isLastEntryInRange(lastKey, endKey, compare, upperExclusive)) {
+      writeIdx = appendLeafSlicePublic(
+        cursorLeaf,
+        cursorIndex,
+        leafCount,
+        output,
+        useIndexed,
+        writeIdx
+      );
+      cursorLeaf = cursorLeaf.next;
+      cursorIndex = 0;
+      continue;
+    }
+    const limit = findBoundaryEnd(
+      state,
+      cursorLeaf,
+      endKey,
+      upperExclusive,
+      leafCount
+    );
+    appendLeafSlicePublic(
+      cursorLeaf,
+      cursorIndex,
+      limit,
+      output,
+      useIndexed,
+      writeIdx
+    );
+    return;
+  }
+};
+var rangeQueryPublicEntries = (state, startKey, endKey, options) => {
+  const cursor = initRangeCursor(state, startKey, endKey, options);
+  if (cursor === null) return [];
+  const output = allocateRangeOutput(state, cursor, startKey, endKey, options);
+  collectPublicEntries(state, cursor, endKey, output);
+  return output;
+};
+var forEachRangeEntries = (state, startKey, endKey, callback, options) => {
+  const cursor = initRangeCursor(state, startKey, endKey, options);
+  if (cursor === null) return;
+  let cursorLeaf = cursor.leaf;
+  let cursorIndex = cursor.index;
+  const { compare, upperExclusive } = cursor;
+  while (cursorLeaf !== null) {
+    const leafCount = leafEntryCount(cursorLeaf);
+    if (cursorIndex >= leafCount) {
+      cursorLeaf = cursorLeaf.next;
+      cursorIndex = 0;
+      continue;
+    }
+    const lastKey = leafEntryAt(cursorLeaf, leafCount - 1).key;
+    if (isLastEntryInRange(lastKey, endKey, compare, upperExclusive)) {
+      for (let i = cursorIndex; i < leafCount; i += 1) {
+        callback(freezeEntry(leafEntryAt(cursorLeaf, i)));
+      }
+      cursorLeaf = cursorLeaf.next;
+      cursorIndex = 0;
+      continue;
+    }
+    const limit = findBoundaryEnd(
+      state,
+      cursorLeaf,
+      endKey,
+      upperExclusive,
+      leafCount
+    );
+    for (let i = cursorIndex; i < limit; i += 1) {
+      callback(freezeEntry(leafEntryAt(cursorLeaf, i)));
+    }
+    return;
+  }
+};
+
+// src/btree/rebalance-branch.ts
 var updateMinKeyInAncestors = (node) => {
   let current = node;
   while (current.parent !== null) {
@@ -426,12 +628,9 @@ var requireParent = (node) => {
   }
   return node.parent;
 };
-var requireLeafNode = (node) => {
-  if (!isLeafNode(node)) throw new BTreeInvariantError("expected leaf, got branch");
-  return node;
-};
 var requireBranchNode = (node) => {
-  if (isLeafNode(node)) throw new BTreeInvariantError("expected branch, got leaf");
+  if (isLeafNode(node))
+    throw new BTreeInvariantError("expected branch, got leaf");
   return node;
 };
 var removeChildFromBranch = (branch, childIndex) => {
@@ -440,27 +639,18 @@ var removeChildFromBranch = (branch, childIndex) => {
   }
   branchRemoveAt(branch, childIndex);
 };
-var detachLeafFromChain = (state, leaf) => {
-  if (leaf.prev !== null) {
-    leaf.prev.next = leaf.next;
-  } else if (leaf.next !== null) {
-    state.leftmostLeaf = leaf.next;
-  }
-  if (leaf.next !== null) {
-    leaf.next.prev = leaf.prev;
-  } else if (leaf.prev !== null) {
-    state.rightmostLeaf = leaf.prev;
-  }
-  leaf.prev = null;
-  leaf.next = null;
-};
 var borrowFromLeftBranch = (branch, leftSibling, branchIndex) => {
   const borrowedChild = leftSibling.children.pop();
-  if (borrowedChild === void 0) throw new BTreeInvariantError("left branch borrow failed");
+  if (borrowedChild === void 0)
+    throw new BTreeInvariantError("left branch borrow failed");
   leftSibling.keys.pop();
   borrowedChild.parent = branch;
-  const borrowedMinKey = { key: void 0, sequence: 0 };
-  if (!writeMinKeyTo(borrowedChild, borrowedMinKey)) throw new BTreeInvariantError("borrowed child has no min key");
+  const borrowedMinKey = {
+    key: void 0,
+    sequence: 0
+  };
+  if (!writeMinKeyTo(borrowedChild, borrowedMinKey))
+    throw new BTreeInvariantError("borrowed child has no min key");
   if (branch.childOffset > 0) {
     branch.childOffset -= 1;
     branch.children[branch.childOffset] = borrowedChild;
@@ -469,15 +659,20 @@ var borrowFromLeftBranch = (branch, leftSibling, branchIndex) => {
   } else {
     branch.children.unshift(borrowedChild);
     branch.keys.unshift(borrowedMinKey);
-    for (let i = 0; i < branch.children.length; i += 1) branch.children[i].indexInParent = i;
+    for (let i = 0; i < branch.children.length; i += 1)
+      branch.children[i].indexInParent = i;
   }
   const parent = requireParent(branch);
-  parent.keys[branchIndex] = { key: borrowedMinKey.key, sequence: borrowedMinKey.sequence };
+  parent.keys[branchIndex] = {
+    key: borrowedMinKey.key,
+    sequence: borrowedMinKey.sequence
+  };
   updateMinKeyInAncestors(branch);
 };
 var borrowFromRightBranch = (branch, rightSibling, branchIndex) => {
   const shiftIdx = rightSibling.childOffset;
-  if (shiftIdx >= rightSibling.children.length) throw new BTreeInvariantError("right branch borrow failed");
+  if (shiftIdx >= rightSibling.children.length)
+    throw new BTreeInvariantError("right branch borrow failed");
   const borrowedChild = rightSibling.children[shiftIdx];
   rightSibling.childOffset += 1;
   if (rightSibling.childOffset >= rightSibling.children.length >>> 1) {
@@ -485,8 +680,12 @@ var borrowFromRightBranch = (branch, rightSibling, branchIndex) => {
   }
   branch.children.push(borrowedChild);
   borrowedChild.parent = branch;
-  const borrowedMinKey = { key: void 0, sequence: 0 };
-  if (!writeMinKeyTo(borrowedChild, borrowedMinKey)) throw new BTreeInvariantError("borrowed child has no min key");
+  const borrowedMinKey = {
+    key: void 0,
+    sequence: 0
+  };
+  if (!writeMinKeyTo(borrowedChild, borrowedMinKey))
+    throw new BTreeInvariantError("borrowed child has no min key");
   branch.keys.push(borrowedMinKey);
   borrowedChild.indexInParent = branch.children.length - 1;
   const parent = requireParent(branch);
@@ -539,7 +738,10 @@ var rebalanceAfterBranchRemoval = (state, branch) => {
   const parent = branch.parent;
   if (parent === null) throw new BTreeInvariantError("branch has no parent");
   const branchIndex = branch.indexInParent;
-  const { left: leftSibling, right: rightSibling } = findBranchSiblings(parent, branchIndex);
+  const { left: leftSibling, right: rightSibling } = findBranchSiblings(
+    parent,
+    branchIndex
+  );
   if (rightSibling !== null && branchChildCount(rightSibling) > state.minBranchChildren) {
     borrowFromRightBranch(branch, rightSibling, branchIndex);
     return;
@@ -558,44 +760,68 @@ var rebalanceAfterBranchRemoval = (state, branch) => {
   }
   throw new BTreeInvariantError("no branch siblings to rebalance");
 };
+
+// src/btree/rebalance.ts
+var requireLeafNode = (node) => {
+  if (!isLeafNode(node))
+    throw new BTreeInvariantError("expected leaf, got branch");
+  return node;
+};
+var detachLeafFromChain = (state, leaf) => {
+  if (leaf.prev !== null) {
+    leaf.prev.next = leaf.next;
+  } else if (leaf.next !== null) {
+    state.leftmostLeaf = leaf.next;
+  }
+  if (leaf.next !== null) {
+    leaf.next.prev = leaf.prev;
+  } else if (leaf.prev !== null) {
+    state.rightmostLeaf = leaf.prev;
+  }
+  leaf.prev = null;
+  leaf.next = null;
+};
 var mergeLeafEntries = (target, source) => {
   if (target.entryOffset > 0) {
     target.entries.copyWithin(0, target.entryOffset);
     target.entries.length = target.entries.length - target.entryOffset;
     target.entryOffset = 0;
   }
-  const src = source.entries;
-  for (let i = source.entryOffset; i < src.length; i += 1) target.entries.push(src[i]);
+  target.entries.push(...source.entries.slice(source.entryOffset));
 };
-var rebalanceAfterLeafRemoval = (state, leaf) => {
-  if (leaf === state.root) {
-    if (state.entryCount === 0) {
-      state.leftmostLeaf = leaf;
-      state.rightmostLeaf = leaf;
-    }
-    return;
+var applyLazyThreshold = (min) => Math.max(1, Math.ceil(min / 4));
+var leafRebalanceThreshold = (state) => {
+  if (state.deleteRebalancePolicy === "lazy") {
+    return applyLazyThreshold(state.minLeafEntries);
   }
-  if (leafEntryCount(leaf) >= state.minLeafEntries) return;
-  const parent = leaf.parent;
-  if (parent === null) throw new BTreeInvariantError("Leaf node has no parent during rebalance.");
-  const leafIndex = leaf.indexInParent;
-  const leftSibling = leafIndex > parent.childOffset ? requireLeafNode(parent.children[leafIndex - 1]) : null;
-  const rightSibling = leafIndex + 1 < parent.children.length ? requireLeafNode(parent.children[leafIndex + 1]) : null;
+  return state.minLeafEntries;
+};
+var findLeafSiblings = (parent, leafIndex) => {
+  const left = leafIndex > parent.childOffset ? requireLeafNode(parent.children[leafIndex - 1]) : null;
+  const right = leafIndex + 1 < parent.children.length ? requireLeafNode(parent.children[leafIndex + 1]) : null;
+  return { left, right };
+};
+var tryBorrowFromLeafSibling = (state, leaf, parent, leafIndex, leftSibling, rightSibling) => {
   if (rightSibling !== null && leafEntryCount(rightSibling) > state.minLeafEntries) {
     const borrowed = leafShiftEntry(rightSibling);
-    if (borrowed === void 0) throw new BTreeInvariantError("right leaf borrow failed");
+    if (borrowed === void 0)
+      throw new BTreeInvariantError("right leaf borrow failed");
     leaf.entries.push(borrowed);
     writeMinKeyTo(rightSibling, parent.keys[leafIndex + 1]);
-    return;
+    return true;
   }
   if (leftSibling !== null && leafEntryCount(leftSibling) > state.minLeafEntries) {
     const borrowed = leftSibling.entries.pop();
-    if (borrowed === void 0) throw new BTreeInvariantError("left leaf borrow failed");
+    if (borrowed === void 0)
+      throw new BTreeInvariantError("left leaf borrow failed");
     leafUnshiftEntry(leaf, borrowed);
     parent.keys[leafIndex] = { key: borrowed.key, sequence: borrowed.entryId };
     updateMinKeyInAncestors(leaf);
-    return;
+    return true;
   }
+  return false;
+};
+var mergeLeafWithSibling = (state, leaf, parent, leafIndex, leftSibling, rightSibling) => {
   if (leftSibling !== null) {
     mergeLeafEntries(leftSibling, leaf);
     detachLeafFromChain(state, leaf);
@@ -612,6 +838,24 @@ var rebalanceAfterLeafRemoval = (state, leaf) => {
   }
   throw new BTreeInvariantError("no leaf siblings to rebalance");
 };
+var rebalanceAfterLeafRemoval = (state, leaf) => {
+  if (leaf === state.root) {
+    if (state.entryCount === 0) {
+      state.leftmostLeaf = leaf;
+      state.rightmostLeaf = leaf;
+    }
+    return;
+  }
+  if (leafEntryCount(leaf) >= leafRebalanceThreshold(state)) return;
+  const parent = leaf.parent;
+  if (parent === null)
+    throw new BTreeInvariantError("Leaf node has no parent during rebalance.");
+  const leafIndex = leaf.indexInParent;
+  const { left, right } = findLeafSiblings(parent, leafIndex);
+  if (tryBorrowFromLeafSibling(state, leaf, parent, leafIndex, left, right))
+    return;
+  mergeLeafWithSibling(state, leaf, parent, leafIndex, left, right);
+};
 
 // src/btree/deleteRange.ts
 var navigateToStart = (state, startKey, lowerExclusive) => {
@@ -624,27 +868,18 @@ var navigateToStart = (state, startKey, lowerExclusive) => {
   }
   return { leaf, idx };
 };
-var findRemoveEnd = (state, leaf, idx, endKey, upperExclusive) => {
+var findRemoveEnd = (state, leaf, endKey, upperExclusive) => {
   const count = leafEntryCount(leaf);
-  let removeEnd = idx;
-  while (removeEnd < count) {
-    const e = leafEntryAt(leaf, removeEnd);
-    const cmpEnd = state.compareKeys(e.key, endKey);
-    if (upperExclusive ? cmpEnd >= 0 : cmpEnd > 0) break;
-    removeEnd += 1;
-  }
-  return removeEnd;
-};
-var computeTreeHeight = (state) => {
-  let h = 0;
-  let n = state.root;
-  while (!isLeafNode(n)) {
-    n = n.children[n.childOffset];
-    h += 1;
+  const lastEntry = leafEntryAt(leaf, count - 1);
+  const cmpLast = state.compareKeys(lastEntry.key, endKey);
+  if (upperExclusive ? cmpLast < 0 : cmpLast <= 0) {
+    return count;
   }
-  return h;
+  const endSeq = upperExclusive ? 0 : Number.MAX_SAFE_INTEGER;
+  const endBound = upperExclusive ? lowerBoundInLeaf(state, leaf, endKey, endSeq) : upperBoundInLeaf(state, leaf, endKey, endSeq);
+  return endBound < count ? endBound : count;
 };
-var spliceLeafAndRebalance = (state, leaf, idx, removeCount, maxRebalanceDepth) => {
+var spliceLeafAndRebalance = (state, leaf, idx, removeCount) => {
   if (state.entryKeys !== null) {
     for (let i = idx; i < idx + removeCount; i += 1) {
       state.entryKeys.delete(leafEntryAt(leaf, i).entryId);
@@ -659,11 +894,13 @@ var spliceLeafAndRebalance = (state, leaf, idx, removeCount, maxRebalanceDepth)
     updateMinKeyInAncestors(leaf);
   }
   const countAfterSplice = leafEntryCount(leaf);
-  let maxIter = maxRebalanceDepth;
-  while (maxIter > 0 && leaf !== state.root && leafEntryCount(leaf) < state.minLeafEntries) {
+  const rebalThreshold = leafRebalanceThreshold(state);
+  let safetyGuard = state.minLeafEntries + 4;
+  while (safetyGuard > 0 && leaf !== state.root && leafEntryCount(leaf) < rebalThreshold) {
     rebalanceAfterLeafRemoval(state, leaf);
-    if (leaf.parent !== null && leaf.parent.children[leaf.indexInParent] !== leaf) break;
-    maxIter -= 1;
+    if (leaf.parent !== null && leaf.parent.children[leaf.indexInParent] !== leaf)
+      break;
+    safetyGuard -= 1;
   }
   if (leafEmptied && leafEntryCount(leaf) > 0 && leaf.parent !== null && leaf.parent.children[leaf.indexInParent] === leaf) {
     updateMinKeyInAncestors(leaf);
@@ -673,12 +910,9 @@ var spliceLeafAndRebalance = (state, leaf, idx, removeCount, maxRebalanceDepth)
 var isLeafStillValid = (state, leaf) => leaf.parent === null ? leaf === state.root : leaf.parent.children[leaf.indexInParent] === leaf;
 var deleteRangeEntries = (state, startKey, endKey, options) => {
   if (state.entryCount === 0) return 0;
-  const boundCompared = state.compareKeys(startKey, endKey);
-  if (boundCompared > 0) return 0;
+  if (isEmptyRange(state.compareKeys, startKey, endKey, options)) return 0;
   const lowerExclusive = options?.lowerBound === "exclusive";
   const upperExclusive = options?.upperBound === "exclusive";
-  if (lowerExclusive && upperExclusive && boundCompared === 0) return 0;
-  const treeHeight = computeTreeHeight(state);
   let deleted = 0;
   let needsNavigate = true;
   let leaf = null;
@@ -693,10 +927,15 @@ var deleteRangeEntries = (state, startKey, endKey, options) => {
     }
     if (idx >= leafEntryCount(leaf)) break;
     const count = leafEntryCount(leaf);
-    const removeEnd = findRemoveEnd(state, leaf, idx, endKey, upperExclusive);
+    const removeEnd = findRemoveEnd(state, leaf, endKey, upperExclusive);
     const removeCount = removeEnd - idx;
     if (removeCount === 0) break;
-    const countAfterSplice = spliceLeafAndRebalance(state, leaf, idx, removeCount, treeHeight);
+    const countAfterSplice = spliceLeafAndRebalance(
+      state,
+      leaf,
+      idx,
+      removeCount
+    );
     deleted += removeCount;
     if (removeEnd < count) break;
     if (!isLeafStillValid(state, leaf)) {
@@ -715,6 +954,7 @@ var deleteRangeEntries = (state, startKey, endKey, options) => {
 };
 
 // src/btree/autoScale.ts
+var minOccupancy = (max) => Math.ceil(max / 2);
 var AUTO_SCALE_TIERS = [
   { threshold: 0, maxLeaf: 32, maxBranch: 32 },
   { threshold: 1e3, maxLeaf: 64, maxBranch: 64 },
@@ -741,33 +981,50 @@ var computeNextAutoScaleThreshold = (entryCount) => {
   }
   return Number.MAX_SAFE_INTEGER;
 };
-var createInitialState = (config) => {
-  if (typeof config.compareKeys !== "function") {
-    throw new BTreeValidationError("compareKeys must be a function.");
-  }
-  const autoScale = config.autoScale === true;
+var resolveInitialCapacity = (config, autoScale) => {
   if (autoScale && (config.maxLeafEntries !== void 0 || config.maxBranchChildren !== void 0)) {
-    throw new BTreeValidationError("autoScale conflicts with explicit capacity.");
+    throw new BTreeValidationError(
+      "autoScale conflicts with explicit capacity."
+    );
   }
-  let maxLeafEntries;
-  let maxBranchChildren;
   if (autoScale) {
     const tier = computeAutoScaleTier(0);
-    maxLeafEntries = tier.maxLeaf;
-    maxBranchChildren = tier.maxBranch;
-  } else {
-    maxLeafEntries = normalizeNodeCapacity(config.maxLeafEntries, "maxLeafEntries", DEFAULT_MAX_LEAF_ENTRIES);
-    maxBranchChildren = normalizeNodeCapacity(config.maxBranchChildren, "maxBranchChildren", DEFAULT_MAX_BRANCH_CHILDREN);
+    return { maxLeafEntries: tier.maxLeaf, maxBranchChildren: tier.maxBranch };
   }
+  return {
+    maxLeafEntries: normalizeNodeCapacity(
+      config.maxLeafEntries,
+      "maxLeafEntries",
+      DEFAULT_MAX_LEAF_ENTRIES
+    ),
+    maxBranchChildren: normalizeNodeCapacity(
+      config.maxBranchChildren,
+      "maxBranchChildren",
+      DEFAULT_MAX_BRANCH_CHILDREN
+    )
+  };
+};
+var createInitialState = (config) => {
+  if (typeof config.compareKeys !== "function") {
+    throw new BTreeValidationError("compareKeys must be a function.");
+  }
+  const autoScale = config.autoScale === true;
+  const { maxLeafEntries, maxBranchChildren } = resolveInitialCapacity(
+    config,
+    autoScale
+  );
   const duplicateKeys = normalizeDuplicateKeyPolicy(config.duplicateKeys);
+  const deleteRebalancePolicy = normalizeDeleteRebalancePolicy(
+    config.deleteRebalancePolicy
+  );
   const emptyLeaf = createLeafNode([], null);
   return {
     compareKeys: config.compareKeys,
     maxLeafEntries,
     maxBranchChildren,
     duplicateKeys,
-    minLeafEntries: Math.ceil(maxLeafEntries / 2),
-    minBranchChildren: Math.ceil(maxBranchChildren / 2),
+    minLeafEntries: minOccupancy(maxLeafEntries),
+    minBranchChildren: minOccupancy(maxBranchChildren),
     root: emptyLeaf,
     leftmostLeaf: emptyLeaf,
     rightmostLeaf: emptyLeaf,
@@ -775,6 +1032,7 @@ var createInitialState = (config) => {
     nextSequence: 0,
     entryKeys: config.enableEntryIdLookup === true ? /* @__PURE__ */ new Map() : null,
     autoScale,
+    deleteRebalancePolicy,
     _nextAutoScaleThreshold: autoScale ? computeNextAutoScaleThreshold(0) : Number.MAX_SAFE_INTEGER,
     _cursor: { leaf: emptyLeaf, index: 0 }
   };
@@ -784,13 +1042,15 @@ var maybeAutoScale = (state) => {
   const { maxLeaf, maxBranch } = computeAutoScaleTier(state.entryCount);
   if (maxLeaf > state.maxLeafEntries) {
     state.maxLeafEntries = maxLeaf;
-    state.minLeafEntries = Math.ceil(maxLeaf / 2);
+    state.minLeafEntries = minOccupancy(maxLeaf);
   }
   if (maxBranch > state.maxBranchChildren) {
     state.maxBranchChildren = maxBranch;
-    state.minBranchChildren = Math.ceil(maxBranch / 2);
+    state.minBranchChildren = minOccupancy(maxBranch);
   }
-  state._nextAutoScaleThreshold = computeNextAutoScaleThreshold(state.entryCount);
+  state._nextAutoScaleThreshold = computeNextAutoScaleThreshold(
+    state.entryCount
+  );
 };
 var applyAutoScaleCapacitySnapshot = (state, maxLeafEntries, maxBranchChildren) => {
   if (!state.autoScale) {
@@ -814,8 +1074,16 @@ var applyAutoScaleCapacitySnapshot = (state, maxLeafEntries, maxBranchChildren)
   }
   state.maxLeafEntries = normalizedLeaf;
   state.maxBranchChildren = normalizedBranch;
-  state.minLeafEntries = Math.ceil(normalizedLeaf / 2);
-  state.minBranchChildren = Math.ceil(normalizedBranch / 2);
+  state.minLeafEntries = minOccupancy(normalizedLeaf);
+  state.minBranchChildren = minOccupancy(normalizedBranch);
+};
+var resetAutoScaleToTier0 = (state) => {
+  const tier = computeAutoScaleTier(0);
+  state.maxLeafEntries = tier.maxLeaf;
+  state.maxBranchChildren = tier.maxBranch;
+  state.minLeafEntries = minOccupancy(tier.maxLeaf);
+  state.minBranchChildren = minOccupancy(tier.maxBranch);
+  state._nextAutoScaleThreshold = computeNextAutoScaleThreshold(0);
 };
 
 // src/btree/bulkLoad.ts
@@ -837,7 +1105,11 @@ var computeChunkBoundaries = (total, max, min) => {
   return boundaries;
 };
 var buildLeaves = (state, entries, ids, baseSequence) => {
-  const boundaries = computeChunkBoundaries(entries.length, state.maxLeafEntries, state.minLeafEntries);
+  const boundaries = computeChunkBoundaries(
+    entries.length,
+    state.maxLeafEntries,
+    state.minLeafEntries
+  );
   const leaves = new Array(boundaries.length);
   let chunkStart = 0;
   for (let c = 0; c < boundaries.length; c += 1) {
@@ -845,7 +1117,11 @@ var buildLeaves = (state, entries, ids, baseSequence) => {
     const chunk = new Array(chunkEnd - chunkStart);
     for (let i = chunkStart; i < chunkEnd; i += 1) {
       const seq = baseSequence + i;
-      chunk[i - chunkStart] = { key: entries[i].key, entryId: seq, value: entries[i].value };
+      chunk[i - chunkStart] = createEntry(
+        entries[i].key,
+        seq,
+        entries[i].value
+      );
       ids[i] = seq;
       if (state.entryKeys !== null) {
         state.entryKeys.set(seq, entries[i].key);
@@ -879,11 +1155,18 @@ var bulkLoadEntries = (state, entries) => {
   } else {
     let currentLevel = leaves;
     while (currentLevel.length > 1) {
-      const bounds = computeChunkBoundaries(currentLevel.length, state.maxBranchChildren, state.minBranchChildren);
+      const bounds = computeChunkBoundaries(
+        currentLevel.length,
+        state.maxBranchChildren,
+        state.minBranchChildren
+      );
       const nextLevel = new Array(bounds.length);
       let start = 0;
       for (let b = 0; b < bounds.length; b += 1) {
-        nextLevel[b] = createBranchNode(currentLevel.slice(start, bounds[b]), null);
+        nextLevel[b] = createBranchNode(
+          currentLevel.slice(start, bounds[b]),
+          null
+        );
         start = bounds[b];
       }
       currentLevel = nextLevel;
@@ -894,9 +1177,12 @@ var bulkLoadEntries = (state, entries) => {
   return ids;
 };
 
-// src/btree/mutations.ts
+// src/btree/split.ts
 var insertChildAfter = (state, parent, existingChild, childToInsert) => {
-  const newChildMinKey = { key: void 0, sequence: 0 };
+  const newChildMinKey = {
+    key: void 0,
+    sequence: 0
+  };
   if (!writeMinKeyTo(childToInsert, newChildMinKey)) {
     throw new BTreeInvariantError("inserted child has no min key");
   }
@@ -924,60 +1210,146 @@ var splitLeaf = (state, leaf) => {
   } else {
     state.rightmostLeaf = sibling;
   }
-  leaf.next = sibling;
-  if (leaf.parent === null) {
-    state.root = createBranchNode([leaf, sibling], null);
-    return;
+  leaf.next = sibling;
+  if (leaf.parent === null) {
+    state.root = createBranchNode([leaf, sibling], null);
+    return;
+  }
+  insertChildAfter(state, leaf.parent, leaf, sibling);
+};
+var splitBranch = (state, branch) => {
+  branchCompact(branch);
+  const splitAt = Math.ceil(branch.children.length / 2);
+  const sibling = createBranchNode(
+    branch.children.splice(splitAt),
+    branch.parent
+  );
+  branch.keys.splice(splitAt);
+  if (branch.parent === null) {
+    state.root = createBranchNode([branch, sibling], null);
+    return;
+  }
+  insertChildAfter(state, branch.parent, branch, sibling);
+};
+
+// src/btree/entry-lookup.ts
+var findLeafEntryBySequence = (state, userKey, sequence) => {
+  const targetLeaf = findLeafForKey(state, userKey, sequence);
+  const index = lowerBoundInLeaf(state, targetLeaf, userKey, sequence);
+  if (index >= leafEntryCount(targetLeaf)) return null;
+  const entry = leafEntryAt(targetLeaf, index);
+  if (entry.entryId !== sequence) return null;
+  return { leaf: targetLeaf, index };
+};
+var peekEntryById = (state, entryId) => {
+  if (state.entryKeys === null) {
+    throw new BTreeInvariantError(
+      "entryKeys lookup map is not enabled on this tree."
+    );
+  }
+  const userKey = state.entryKeys.get(entryId);
+  if (userKey === void 0) return null;
+  const found = findLeafEntryBySequence(state, userKey, entryId);
+  if (found === null) return null;
+  const entry = leafEntryAt(found.leaf, found.index);
+  return entry;
+};
+var updateEntryById = (state, entryId, newValue) => {
+  if (state.entryKeys === null) {
+    throw new BTreeInvariantError(
+      "entryKeys lookup map is not enabled on this tree."
+    );
+  }
+  const userKey = state.entryKeys.get(entryId);
+  if (userKey === void 0) return null;
+  const found = findLeafEntryBySequence(state, userKey, entryId);
+  if (found === null) return null;
+  const entry = leafEntryAt(found.leaf, found.index);
+  const updated = createEntry(entry.key, entry.entryId, newValue);
+  found.leaf.entries[found.leaf.entryOffset + found.index] = updated;
+  return updated;
+};
+var removeEntryById = (state, entryId) => {
+  if (state.entryKeys === null) {
+    throw new BTreeInvariantError(
+      "entryKeys lookup map is not enabled on this tree."
+    );
+  }
+  const userKey = state.entryKeys.get(entryId);
+  if (userKey === void 0) return null;
+  const found = findLeafEntryBySequence(state, userKey, entryId);
+  if (found === null) return null;
+  const entry = leafEntryAt(found.leaf, found.index);
+  leafRemoveAt(found.leaf, found.index);
+  state.entryCount -= 1;
+  state.entryKeys.delete(entryId);
+  if (found.index === 0 && leafEntryCount(found.leaf) > 0 && found.leaf.parent !== null) {
+    updateMinKeyInAncestors(found.leaf);
+  }
+  if (found.leaf !== state.root && leafEntryCount(found.leaf) < state.minLeafEntries) {
+    rebalanceAfterLeafRemoval(state, found.leaf);
   }
-  insertChildAfter(state, leaf.parent, leaf, sibling);
+  return entry;
 };
-var splitBranch = (state, branch) => {
-  branchCompact(branch);
-  const splitAt = Math.ceil(branch.children.length / 2);
-  const sibling = createBranchNode(branch.children.splice(splitAt), branch.parent);
-  branch.keys.splice(splitAt);
-  if (branch.parent === null) {
-    state.root = createBranchNode([branch, sibling], null);
-    return;
+
+// src/btree/mutations.ts
+var findDuplicateEntry = (state, targetLeaf, key, insertAt) => {
+  if (state.duplicateKeys === "allow") return null;
+  if (insertAt > 0) {
+    const candidate = leafEntryAt(targetLeaf, insertAt - 1);
+    if (state.compareKeys(candidate.key, key) === 0) {
+      return {
+        leaf: targetLeaf,
+        physIndex: targetLeaf.entryOffset + insertAt - 1,
+        entry: candidate
+      };
+    }
+  } else if (targetLeaf.prev !== null && leafEntryCount(targetLeaf.prev) > 0) {
+    const prevLeaf = targetLeaf.prev;
+    const prevCount = leafEntryCount(prevLeaf);
+    const candidate = leafEntryAt(prevLeaf, prevCount - 1);
+    if (state.compareKeys(candidate.key, key) === 0) {
+      return {
+        leaf: prevLeaf,
+        physIndex: prevLeaf.entryOffset + prevCount - 1,
+        entry: candidate
+      };
+    }
   }
-  insertChildAfter(state, branch.parent, branch, sibling);
+  return null;
 };
 var putEntryIntoLeaf = (state, targetLeaf, key, value) => {
   const sequence = state.nextSequence;
   const insertAt = upperBoundInLeaf(state, targetLeaf, key, sequence);
-  if (state.duplicateKeys !== "allow") {
-    let existingEntry = null;
-    if (insertAt > 0) {
-      const candidate = leafEntryAt(targetLeaf, insertAt - 1);
-      if (state.compareKeys(candidate.key, key) === 0) {
-        existingEntry = candidate;
-      }
-    } else if (targetLeaf.prev !== null && leafEntryCount(targetLeaf.prev) > 0) {
-      const prevLeaf = targetLeaf.prev;
-      const candidate = leafEntryAt(prevLeaf, leafEntryCount(prevLeaf) - 1);
-      if (state.compareKeys(candidate.key, key) === 0) {
-        existingEntry = candidate;
-      }
-    }
-    if (existingEntry !== null) {
-      if (state.duplicateKeys === "reject") {
-        throw new BTreeValidationError("Duplicate key rejected.");
-      }
-      existingEntry.value = value;
-      return existingEntry.entryId;
-    }
+  const dup = findDuplicateEntry(state, targetLeaf, key, insertAt);
+  if (dup !== null) {
+    if (state.duplicateKeys === "reject") {
+      throw new BTreeValidationError("Duplicate key rejected.");
+    }
+    dup.leaf.entries[dup.physIndex] = createEntry(
+      dup.entry.key,
+      dup.entry.entryId,
+      value
+    );
+    return dup.entry.entryId;
   }
   if (state.nextSequence >= Number.MAX_SAFE_INTEGER) {
     throw new BTreeValidationError("Sequence overflow.");
   }
   state.nextSequence += 1;
-  leafInsertAt(targetLeaf, insertAt, { key, entryId: sequence, value });
+  leafInsertAt(
+    targetLeaf,
+    insertAt,
+    createEntry(key, sequence, value)
+  );
   state.entryCount += 1;
   if (state.entryKeys !== null) {
     state.entryKeys.set(sequence, key);
   }
-  if (insertAt === 0 && targetLeaf.parent !== null) updateMinKeyInAncestors(targetLeaf);
-  if (leafEntryCount(targetLeaf) > state.maxLeafEntries) splitLeaf(state, targetLeaf);
+  if (insertAt === 0 && targetLeaf.parent !== null)
+    updateMinKeyInAncestors(targetLeaf);
+  if (leafEntryCount(targetLeaf) > state.maxLeafEntries)
+    splitLeaf(state, targetLeaf);
   maybeAutoScale(state);
   return sequence;
 };
@@ -988,7 +1360,8 @@ var putEntry = (state, key, value) => {
 var popFirstEntry = (state) => {
   if (state.entryCount === 0) return null;
   const firstEntry = leafShiftEntry(state.leftmostLeaf);
-  if (firstEntry === void 0) throw new BTreeInvariantError("leftmost leaf empty but count > 0");
+  if (firstEntry === void 0)
+    throw new BTreeInvariantError("leftmost leaf empty but count > 0");
   state.entryCount -= 1;
   if (state.entryKeys !== null) {
     state.entryKeys.delete(firstEntry.entryId);
@@ -1004,7 +1377,8 @@ var popFirstEntry = (state) => {
 var popLastEntry = (state) => {
   if (state.entryCount === 0) return null;
   const lastEntry = leafPopEntry(state.rightmostLeaf);
-  if (lastEntry === void 0) throw new BTreeInvariantError("rightmost leaf empty but count > 0");
+  if (lastEntry === void 0)
+    throw new BTreeInvariantError("rightmost leaf empty but count > 0");
   state.entryCount -= 1;
   if (state.entryKeys !== null) {
     state.entryKeys.delete(lastEntry.entryId);
@@ -1025,62 +1399,26 @@ var removeFirstMatchingEntry = (state, key) => {
   if (state.entryKeys !== null) {
     state.entryKeys.delete(targetEntry.entryId);
   }
-  if (removeAt === 0 && leafEntryCount(targetLeaf) > 0 && targetLeaf.parent !== null) updateMinKeyInAncestors(targetLeaf);
+  if (removeAt === 0 && leafEntryCount(targetLeaf) > 0 && targetLeaf.parent !== null)
+    updateMinKeyInAncestors(targetLeaf);
   if (targetLeaf !== state.root && leafEntryCount(targetLeaf) < state.minLeafEntries) {
     rebalanceAfterLeafRemoval(state, targetLeaf);
   }
   return targetEntry;
 };
-var findLeafEntryBySequence = (state, userKey, sequence) => {
-  const targetLeaf = findLeafForKey(state, userKey, sequence);
-  const index = lowerBoundInLeaf(state, targetLeaf, userKey, sequence);
-  if (index >= leafEntryCount(targetLeaf)) return null;
-  const entry = leafEntryAt(targetLeaf, index);
-  if (entry.entryId !== sequence) return null;
-  return { leaf: targetLeaf, index };
-};
-var removeEntryById = (state, entryId) => {
-  const userKey = state.entryKeys.get(entryId);
-  if (userKey === void 0) return null;
-  const found = findLeafEntryBySequence(state, userKey, entryId);
-  if (found === null) return null;
-  const entry = leafEntryAt(found.leaf, found.index);
-  leafRemoveAt(found.leaf, found.index);
-  state.entryCount -= 1;
-  state.entryKeys.delete(entryId);
-  if (found.index === 0 && leafEntryCount(found.leaf) > 0 && found.leaf.parent !== null) {
-    updateMinKeyInAncestors(found.leaf);
-  }
-  if (found.leaf !== state.root && leafEntryCount(found.leaf) < state.minLeafEntries) {
-    rebalanceAfterLeafRemoval(state, found.leaf);
-  }
-  return entry;
-};
-var peekEntryById = (state, entryId) => {
-  const userKey = state.entryKeys.get(entryId);
-  if (userKey === void 0) return null;
-  const found = findLeafEntryBySequence(state, userKey, entryId);
-  if (found === null) return null;
-  const entry = leafEntryAt(found.leaf, found.index);
-  return entry;
-};
-var updateEntryById = (state, entryId, newValue) => {
-  const userKey = state.entryKeys.get(entryId);
-  if (userKey === void 0) return null;
-  const found = findLeafEntryBySequence(state, userKey, entryId);
-  if (found === null) return null;
-  const entry = leafEntryAt(found.leaf, found.index);
-  entry.value = newValue;
-  return entry;
-};
 var putManyEntries = (state, entries) => {
   if (entries.length === 0) return [];
   const strictlyAscending = state.duplicateKeys !== "allow";
   for (let i = 1; i < entries.length; i += 1) {
     const cmp = state.compareKeys(entries[i - 1].key, entries[i].key);
-    if (strictlyAscending ? cmp >= 0 : cmp > 0) {
+    if (cmp > 0) {
+      throw new BTreeValidationError(
+        "putMany: entries not in ascending order."
+      );
+    }
+    if (strictlyAscending && cmp === 0) {
       throw new BTreeValidationError(
-        strictlyAscending ? "putMany: not sorted in strict ascending order." : "putMany: not sorted in non-descending order."
+        state.duplicateKeys === "reject" ? "putMany: duplicate key rejected." : "putMany: equal keys not allowed in strict mode."
       );
     }
   }
@@ -1089,7 +1427,12 @@ var putManyEntries = (state, entries) => {
     let hintLeaf = findLeafForKey(state, entries[0].key, state.nextSequence);
     for (let i = 0; i < entries.length; i += 1) {
       const entry = entries[i];
-      const targetLeaf = findLeafFromHint(state, hintLeaf, entry.key, state.nextSequence);
+      const targetLeaf = findLeafFromHint(
+        state,
+        hintLeaf,
+        entry.key,
+        state.nextSequence
+      );
       ids[i] = putEntryIntoLeaf(state, targetLeaf, entry.key, entry.value);
       hintLeaf = targetLeaf;
     }
@@ -1098,116 +1441,14 @@ var putManyEntries = (state, entries) => {
   return bulkLoadEntries(state, entries);
 };
 
-// src/btree/rangeQuery.ts
-var initRangeCursor = (state, startKey, endKey, options) => {
-  if (state.entryCount === 0) return null;
-  const compare = state.compareKeys;
-  const boundCompared = compare(startKey, endKey);
-  if (boundCompared > 0) return null;
-  const lowerExclusive = options?.lowerBound === "exclusive";
-  const upperExclusive = options?.upperBound === "exclusive";
-  if (lowerExclusive && upperExclusive && boundCompared === 0) return null;
-  const startSeq = lowerExclusive ? Number.MAX_SAFE_INTEGER : 0;
-  const leaf = findLeafForKey(state, startKey, startSeq);
-  const index = lowerExclusive ? upperBoundInLeaf(state, leaf, startKey, Number.MAX_SAFE_INTEGER) : lowerBoundInLeaf(state, leaf, startKey, 0);
-  return { leaf, index, compare, upperExclusive };
-};
-var countRangeEntries = (state, startKey, endKey, options) => {
-  const cursor = initRangeCursor(state, startKey, endKey, options);
-  if (cursor === null) return 0;
-  let cursorLeaf = cursor.leaf;
-  let cursorIndex = cursor.index;
-  const { compare, upperExclusive } = cursor;
-  let count = 0;
-  while (cursorLeaf !== null) {
-    const leafCount = leafEntryCount(cursorLeaf);
-    if (cursorIndex >= leafCount) {
-      cursorLeaf = cursorLeaf.next;
-      cursorIndex = 0;
-      continue;
-    }
-    const lastEntry = leafEntryAt(cursorLeaf, leafCount - 1);
-    const cmpLast = compare(lastEntry.key, endKey);
-    if (upperExclusive ? cmpLast < 0 : cmpLast <= 0) {
-      count += leafCount - cursorIndex;
-      cursorLeaf = cursorLeaf.next;
-      cursorIndex = 0;
-      continue;
-    }
-    const endSeq = upperExclusive ? 0 : Number.MAX_SAFE_INTEGER;
-    const endBound = upperExclusive ? lowerBoundInLeaf(state, cursorLeaf, endKey, endSeq) : upperBoundInLeaf(state, cursorLeaf, endKey, endSeq);
-    const limit = endBound < leafCount ? endBound : leafCount;
-    count += limit - cursorIndex;
-    return count;
-  }
-  return count;
-};
-var RANGE_PREALLOC_THRESHOLD = 200;
-var allocateRangeOutput = (state, cursorLeaf, cursorIndex, compare, upperExclusive, startKey, endKey, options) => {
-  const firstLeafCount = leafEntryCount(cursorLeaf);
-  const firstLeafRemainder = firstLeafCount - cursorIndex;
-  if (firstLeafRemainder >= RANGE_PREALLOC_THRESHOLD && cursorLeaf.next !== null) {
-    const lastEntry = leafEntryAt(cursorLeaf, firstLeafCount - 1);
-    const cmpLast = compare(lastEntry.key, endKey);
-    if (upperExclusive ? cmpLast < 0 : cmpLast <= 0) {
-      const total = countRangeEntries(state, startKey, endKey, options);
-      return new Array(total);
-    }
-  }
-  return [];
-};
-var appendLeafSlice = (leaf, from, to, output, useIndexed, writeIdx) => {
-  if (useIndexed) {
-    for (let i = from; i < to; i += 1) {
-      output[writeIdx++] = leafEntryAt(leaf, i);
-    }
-  } else {
-    for (let i = from; i < to; i += 1) {
-      output.push(leafEntryAt(leaf, i));
-    }
-  }
-  return writeIdx;
-};
-var rangeQueryEntries = (state, startKey, endKey, options) => {
-  const cursor = initRangeCursor(state, startKey, endKey, options);
-  if (cursor === null) return [];
-  let cursorLeaf = cursor.leaf;
-  let cursorIndex = cursor.index;
-  const { compare, upperExclusive } = cursor;
-  const output = allocateRangeOutput(state, cursorLeaf, cursorIndex, compare, upperExclusive, startKey, endKey, options);
-  let writeIdx = 0;
-  const useIndexed = output.length > 0;
-  while (cursorLeaf !== null) {
-    const leafCount = leafEntryCount(cursorLeaf);
-    if (cursorIndex >= leafCount) {
-      cursorLeaf = cursorLeaf.next;
-      cursorIndex = 0;
-      continue;
-    }
-    const lastEntry = leafEntryAt(cursorLeaf, leafCount - 1);
-    const cmpLast = compare(lastEntry.key, endKey);
-    if (upperExclusive ? cmpLast < 0 : cmpLast <= 0) {
-      writeIdx = appendLeafSlice(cursorLeaf, cursorIndex, leafCount, output, useIndexed, writeIdx);
-      cursorLeaf = cursorLeaf.next;
-      cursorIndex = 0;
-      continue;
-    }
-    const endSeq = upperExclusive ? 0 : Number.MAX_SAFE_INTEGER;
-    const endBound = upperExclusive ? lowerBoundInLeaf(state, cursorLeaf, endKey, endSeq) : upperBoundInLeaf(state, cursorLeaf, endKey, endSeq);
-    const limit = endBound < leafCount ? endBound : leafCount;
-    appendLeafSlice(cursorLeaf, cursorIndex, limit, output, useIndexed, writeIdx);
-    return output;
-  }
-  return output;
-};
-
 // src/btree/serialization.ts
 var buildConfigFromState = (state) => {
   const config = {
     compareKeys: state.compareKeys,
     duplicateKeys: state.duplicateKeys,
     enableEntryIdLookup: state.entryKeys !== null,
-    autoScale: state.autoScale
+    autoScale: state.autoScale,
+    deleteRebalancePolicy: state.deleteRebalancePolicy
   };
   if (!state.autoScale) {
     config.maxLeafEntries = state.maxLeafEntries;
@@ -1227,17 +1468,17 @@ var serializeToJSON = (state) => {
     }
     leaf = leaf.next;
   }
-  return {
-    version: 1,
-    config: {
-      maxLeafEntries: state.maxLeafEntries,
-      maxBranchChildren: state.maxBranchChildren,
-      duplicateKeys: state.duplicateKeys,
-      enableEntryIdLookup: state.entryKeys !== null,
-      autoScale: state.autoScale
-    },
-    entries
+  const config = {
+    maxLeafEntries: state.maxLeafEntries,
+    maxBranchChildren: state.maxBranchChildren,
+    duplicateKeys: state.duplicateKeys,
+    enableEntryIdLookup: state.entryKeys !== null,
+    autoScale: state.autoScale
   };
+  if (state.deleteRebalancePolicy !== "standard") {
+    config.deleteRebalancePolicy = state.deleteRebalancePolicy;
+  }
+  return { version: 1, config, entries };
 };
 var MAX_SERIALIZED_ENTRIES = 1e6;
 var validateStructure = (json) => {
@@ -1300,13 +1541,28 @@ var validateBTreeJSON = (json) => {
   validateStructure(json);
   validateConfig(json.config);
 };
+var validateBTreeJSONSortOrder = (json, compareKeys) => {
+  const strict = json.config.duplicateKeys !== "allow";
+  for (let i = 1; i < json.entries.length; i += 1) {
+    const cmp = compareKeys(json.entries[i - 1][0], json.entries[i][0]);
+    if (cmp > 0) {
+      throw new BTreeValidationError("fromJSON: entries not sorted.");
+    }
+    if (strict && cmp === 0) {
+      throw new BTreeValidationError(
+        'fromJSON: duplicate keys require duplicateKeys "allow".'
+      );
+    }
+  }
+};
 var buildConfigFromJSON = (json, compareKeys) => {
   const cfg = json.config;
   const config = {
     compareKeys,
     duplicateKeys: cfg.duplicateKeys,
     enableEntryIdLookup: cfg.enableEntryIdLookup,
-    autoScale: cfg.autoScale
+    autoScale: cfg.autoScale,
+    deleteRebalancePolicy: cfg.deleteRebalancePolicy
   };
   if (!cfg.autoScale) {
     config.maxLeafEntries = cfg.maxLeafEntries;
@@ -1315,6 +1571,44 @@ var buildConfigFromJSON = (json, compareKeys) => {
   return config;
 };
 
+// src/btree/traversal.ts
+var snapshotEntries = (state) => {
+  const result = new Array(state.entryCount);
+  let leaf = state.leftmostLeaf;
+  let writeIdx = 0;
+  while (leaf !== null) {
+    const count = leafEntryCount(leaf);
+    for (let i = 0; i < count; i += 1) {
+      result[writeIdx++] = freezeEntry(leafEntryAt(leaf, i));
+    }
+    leaf = leaf.next;
+  }
+  return result;
+};
+var collectInternalEntries = (state) => {
+  const result = new Array(state.entryCount);
+  let leaf = state.leftmostLeaf;
+  let writeIdx = 0;
+  while (leaf !== null) {
+    const count = leafEntryCount(leaf);
+    for (let i = 0; i < count; i += 1) {
+      result[writeIdx++] = leafEntryAt(leaf, i);
+    }
+    leaf = leaf.next;
+  }
+  return result;
+};
+var forEachEntry = (state, callback, thisArg) => {
+  let leaf = state.leftmostLeaf;
+  while (leaf !== null) {
+    const count = leafEntryCount(leaf);
+    for (let i = 0; i < count; i += 1) {
+      callback.call(thisArg, freezeEntry(leafEntryAt(leaf, i)));
+    }
+    leaf = leaf.next;
+  }
+};
+
 // src/btree/integrity-helpers.ts
 var nodeMinKey = (node) => {
   if (isLeafNode(node)) {
@@ -1323,14 +1617,17 @@ var nodeMinKey = (node) => {
     return { key: e.key, sequence: e.entryId };
   }
   if (node.childOffset >= node.keys.length) return null;
-  return { key: node.keys[node.childOffset].key, sequence: node.keys[node.childOffset].sequence };
+  return {
+    key: node.keys[node.childOffset].key,
+    sequence: node.keys[node.childOffset].sequence
+  };
 };
 var compareNodeKeys = (comparator, leftKey, leftSeq, rightKey, rightSeq) => {
   const cmp = comparator(leftKey, rightKey);
   if (cmp !== 0) {
     return cmp;
   }
-  return leftSeq - rightSeq;
+  return leftSeq < rightSeq ? -1 : leftSeq > rightSeq ? 1 : 0;
 };
 var getNodeMaxKey = (node) => {
   if (isLeafNode(node)) {
@@ -1345,9 +1642,7 @@ var getNodeMaxKey = (node) => {
 };
 var validateComparatorResult = (result) => {
   if (!Number.isFinite(result)) {
-    throw new BTreeValidationError(
-      "compareKeys must return a finite number."
-    );
+    throw new BTreeValidationError("compareKeys must return a finite number.");
   }
   return result;
 };
@@ -1407,6 +1702,34 @@ var assertTransitivityAsInvariant = (state, first, second, third) => {
     throw error;
   }
 };
+var validateAdjacentLeafOrdering = (state, previous, cursor) => {
+  const prevMax = getNodeMaxKey(previous);
+  const currentMin = nodeMinKey(cursor);
+  if (prevMax === null || currentMin === null) {
+    throw new BTreeInvariantError(
+      "Non-empty tree leaf chain contains empty leaf node."
+    );
+  }
+  if (compareNodeKeys(
+    state.compareKeys,
+    prevMax.key,
+    prevMax.sequence,
+    currentMin.key,
+    currentMin.sequence
+  ) > 0) {
+    throw new BTreeInvariantError("Adjacent leaf key ranges are out of order.");
+  }
+  const prevCount = leafEntryCount(previous);
+  const curCount = leafEntryCount(cursor);
+  if (state.duplicateKeys !== "allow" && prevCount > 0 && curCount > 0 && state.compareKeys(
+    leafEntryAt(previous, prevCount - 1).key,
+    leafEntryAt(cursor, 0).key
+  ) === 0) {
+    throw new BTreeInvariantError(
+      "Duplicate user key detected across adjacent leaves with uniqueness policy."
+    );
+  }
+};
 var validateLeafChainStep = (state, cursor, previous, visited) => {
   if (!isLeafNode(cursor)) {
     throw new BTreeInvariantError("Leaf linkage cursor reached non-leaf node.");
@@ -1418,22 +1741,7 @@ var validateLeafChainStep = (state, cursor, previous, visited) => {
     throw new BTreeInvariantError("Leaf prev pointer mismatch.");
   }
   if (previous !== null && isLeafNode(previous)) {
-    const prevMax = getNodeMaxKey(previous);
-    const currentMin = nodeMinKey(cursor);
-    if (prevMax === null || currentMin === null) {
-      throw new BTreeInvariantError("Non-empty tree leaf chain contains empty leaf node.");
-    }
-    if (compareNodeKeys(state.compareKeys, prevMax.key, prevMax.sequence, currentMin.key, currentMin.sequence) > 0) {
-      throw new BTreeInvariantError("Adjacent leaf key ranges are out of order.");
-    }
-    const prevCount = leafEntryCount(previous);
-    const curCount = leafEntryCount(cursor);
-    if (state.duplicateKeys !== "allow" && prevCount > 0 && curCount > 0 && state.compareKeys(
-      leafEntryAt(previous, prevCount - 1).key,
-      leafEntryAt(cursor, 0).key
-    ) === 0) {
-      throw new BTreeInvariantError("Duplicate user key detected across adjacent leaves with uniqueness policy.");
-    }
+    validateAdjacentLeafOrdering(state, previous, cursor);
   }
 };
 var validateLeafLinks = (state, expectedLeafCount) => {
@@ -1442,7 +1750,9 @@ var validateLeafLinks = (state, expectedLeafCount) => {
       throw new BTreeInvariantError("Empty tree root must be a leaf node.");
     }
     if (state.leftmostLeaf !== state.root || state.rightmostLeaf !== state.root) {
-      throw new BTreeInvariantError("Empty tree leaf pointers must reference root leaf.");
+      throw new BTreeInvariantError(
+        "Empty tree leaf pointers must reference root leaf."
+      );
     }
     return;
   }
@@ -1467,7 +1777,9 @@ var validateLeafLinks = (state, expectedLeafCount) => {
     throw new BTreeInvariantError("Rightmost leaf pointer mismatch.");
   }
   if (leafCount !== expectedLeafCount) {
-    throw new BTreeInvariantError("Leaf chain count mismatch with tree traversal count.");
+    throw new BTreeInvariantError(
+      "Leaf chain count mismatch with tree traversal count."
+    );
   }
 };
 
@@ -1494,7 +1806,9 @@ var validateLeafNodeOrdering = (state, node) => {
         leafEntryAt(node, index - 1).key,
         leafEntryAt(node, index).key
       ) === 0) {
-        throw new BTreeInvariantError("Duplicate user key detected in tree with uniqueness policy.");
+        throw new BTreeInvariantError(
+          "Duplicate user key detected in tree with uniqueness policy."
+        );
       }
     }
   }
@@ -1502,12 +1816,7 @@ var validateLeafNodeOrdering = (state, node) => {
     const first = leafEntryAt(node, index - 2);
     const second = leafEntryAt(node, index - 1);
     const third = leafEntryAt(node, index);
-    assertTransitivityAsInvariant(
-      state,
-      first.key,
-      second.key,
-      third.key
-    );
+    assertTransitivityAsInvariant(state, first.key, second.key, third.key);
   }
   if (count > state.maxLeafEntries) {
     throw new BTreeInvariantError("Leaf node exceeds maximum occupancy.");
@@ -1516,9 +1825,14 @@ var validateLeafNodeOrdering = (state, node) => {
 var validateLeafNode = (state, node, depth) => {
   validateLeafNodeOrdering(state, node);
   const count = leafEntryCount(node);
-  const baseMinLeaf = state.autoScale ? Math.ceil(computeAutoScaleTier(0).maxLeaf / 2) : state.minLeafEntries;
+  let baseMinLeaf = state.autoScale ? Math.ceil(computeAutoScaleTier(0).maxLeaf / 2) : state.minLeafEntries;
+  if (state.deleteRebalancePolicy === "lazy") {
+    baseMinLeaf = applyLazyThreshold(baseMinLeaf);
+  }
   if (node !== state.root && count < baseMinLeaf) {
-    throw new BTreeInvariantError("Non-root leaf node violates minimum occupancy.");
+    throw new BTreeInvariantError(
+      "Non-root leaf node violates minimum occupancy."
+    );
   }
   const first = count === 0 ? null : leafEntryAt(node, 0);
   const last = count === 0 ? null : leafEntryAt(node, count - 1);
@@ -1540,76 +1854,110 @@ var validateBranchStructure = (state, node) => {
   }
   const baseMinBranch = state.autoScale ? Math.ceil(computeAutoScaleTier(0).maxBranch / 2) : state.minBranchChildren;
   if (node !== state.root && liveCount < baseMinBranch) {
-    throw new BTreeInvariantError("Non-root branch node violates minimum occupancy.");
+    throw new BTreeInvariantError(
+      "Non-root branch node violates minimum occupancy."
+    );
   }
   if (liveCount > state.maxBranchChildren) {
     throw new BTreeInvariantError("Branch node exceeds maximum occupancy.");
   }
   if (node.keys.length !== node.children.length) {
-    throw new BTreeInvariantError("Branch keys array length does not match children array length.");
+    throw new BTreeInvariantError(
+      "Branch keys array length does not match children array length."
+    );
   }
 };
 var validateBranchChild = (state, node, childIndex, depth) => {
   const child = node.children[childIndex];
   if (child.parent !== node) {
-    throw new BTreeInvariantError("Child-parent pointer mismatch in branch node.");
+    throw new BTreeInvariantError(
+      "Child-parent pointer mismatch in branch node."
+    );
   }
   if (child.indexInParent !== childIndex) {
-    throw new BTreeInvariantError("Child indexInParent does not match actual position in parent.");
+    throw new BTreeInvariantError(
+      "Child indexInParent does not match actual position in parent."
+    );
   }
   const childValidation = validateNode(state, child, depth + 1);
   if (childValidation.minKey === null || childValidation.maxKey === null) {
-    throw new BTreeInvariantError("Branch child must not be empty in non-root branch tree.");
+    throw new BTreeInvariantError(
+      "Branch child must not be empty in non-root branch tree."
+    );
   }
   const cachedMinKey = node.keys[childIndex];
   const actualMinKey = nodeMinKey(child);
-  if (actualMinKey === null || compareNodeKeys(state.compareKeys, cachedMinKey.key, cachedMinKey.sequence, actualMinKey.key, actualMinKey.sequence) !== 0) {
-    throw new BTreeInvariantError("Branch cached key does not match actual child minimum key.");
+  if (actualMinKey === null || compareNodeKeys(
+    state.compareKeys,
+    cachedMinKey.key,
+    cachedMinKey.sequence,
+    actualMinKey.key,
+    actualMinKey.sequence
+  ) !== 0) {
+    throw new BTreeInvariantError(
+      "Branch cached key does not match actual child minimum key."
+    );
   }
   return childValidation;
 };
+var mergeChildValidation = (state, accumulated, childValidation) => {
+  if (accumulated.leafDepth !== null && childValidation.leafDepth !== null && childValidation.leafDepth !== accumulated.leafDepth) {
+    throw new BTreeInvariantError("Leaf depth mismatch detected in tree.");
+  }
+  if (accumulated.leafDepth === null && childValidation.leafDepth !== null) {
+    accumulated.leafDepth = childValidation.leafDepth;
+  }
+  if (accumulated.previousChildMax !== null && compareNodeKeys(
+    state.compareKeys,
+    accumulated.previousChildMax.key,
+    accumulated.previousChildMax.sequence,
+    childValidation.minKey.key,
+    childValidation.minKey.sequence
+  ) >= 0) {
+    throw new BTreeInvariantError(
+      "Branch child key ranges are not strictly ordered."
+    );
+  }
+  if (accumulated.minKey === null) accumulated.minKey = childValidation.minKey;
+  accumulated.maxKey = childValidation.maxKey;
+  accumulated.previousChildMax = childValidation.maxKey;
+  accumulated.leafCount += childValidation.leafCount;
+  accumulated.branchCount += childValidation.branchCount;
+  accumulated.entryCount += childValidation.entryCount;
+};
 var validateNode = (state, node, depth) => {
   if (isLeafNode(node)) {
     return validateLeafNode(state, node, depth);
   }
   validateBranchStructure(state, node);
-  let leafDepth = null;
-  let leafCount = 0;
-  let branchCount = 1;
-  let entryCount = 0;
-  let minKey = null;
-  let maxKey = null;
-  let previousChildMax = null;
+  const acc = {
+    leafDepth: null,
+    leafCount: 0,
+    branchCount: 1,
+    entryCount: 0,
+    minKey: null,
+    maxKey: null,
+    previousChildMax: null
+  };
   for (let childIndex = node.childOffset; childIndex < node.children.length; childIndex += 1) {
     const childValidation = validateBranchChild(state, node, childIndex, depth);
-    if (leafDepth !== null && childValidation.leafDepth !== null && childValidation.leafDepth !== leafDepth) {
-      throw new BTreeInvariantError("Leaf depth mismatch detected in tree.");
-    }
-    if (leafDepth === null && childValidation.leafDepth !== null) {
-      leafDepth = childValidation.leafDepth;
-    }
-    if (previousChildMax !== null && compareNodeKeys(
-      state.compareKeys,
-      previousChildMax.key,
-      previousChildMax.sequence,
-      childValidation.minKey.key,
-      childValidation.minKey.sequence
-    ) >= 0) {
-      throw new BTreeInvariantError("Branch child key ranges are not strictly ordered.");
-    }
-    if (minKey === null) minKey = childValidation.minKey;
-    maxKey = childValidation.maxKey;
-    previousChildMax = childValidation.maxKey;
-    leafCount += childValidation.leafCount;
-    branchCount += childValidation.branchCount;
-    entryCount += childValidation.entryCount;
+    mergeChildValidation(state, acc, childValidation);
   }
-  return { minKey, maxKey, leafDepth, leafCount, branchCount, entryCount };
+  return {
+    minKey: acc.minKey,
+    maxKey: acc.maxKey,
+    leafDepth: acc.leafDepth,
+    leafCount: acc.leafCount,
+    branchCount: acc.branchCount,
+    entryCount: acc.entryCount
+  };
 };
 var assertInvariants = (state) => {
   const validation = validateNode(state, state.root, 0);
   if (validation.entryCount !== state.entryCount) {
-    throw new BTreeInvariantError("Index entry count mismatch between tree traversal and tracked state.");
+    throw new BTreeInvariantError(
+      "Index entry count mismatch between tree traversal and tracked state."
+    );
   }
   validateLeafLinks(state, validation.leafCount);
 };
@@ -1663,44 +2011,56 @@ var InMemoryBTree = class _InMemoryBTree {
     return putManyEntries(this.state, entries);
   }
   remove(key) {
-    return removeFirstMatchingEntry(this.state, key);
+    const entry = removeFirstMatchingEntry(this.state, key);
+    if (entry === null) return null;
+    return freezeEntry(entry);
   }
   removeById(entryId) {
     if (this.state.entryKeys === null) {
       throw new BTreeValidationError("Requires enableEntryIdLookup: true.");
     }
-    return removeEntryById(this.state, entryId);
+    const entry = removeEntryById(this.state, entryId);
+    if (entry === null) return null;
+    return freezeEntry(entry);
   }
   peekById(entryId) {
     if (this.state.entryKeys === null) {
       throw new BTreeValidationError("Requires enableEntryIdLookup: true.");
     }
-    return peekEntryById(this.state, entryId);
+    const entry = peekEntryById(this.state, entryId);
+    if (entry === null) return null;
+    return freezeEntry(entry);
   }
   updateById(entryId, value) {
     if (this.state.entryKeys === null) {
       throw new BTreeValidationError("Requires enableEntryIdLookup: true.");
     }
-    return updateEntryById(this.state, entryId, value);
+    const entry = updateEntryById(this.state, entryId, value);
+    if (entry === null) return null;
+    return freezeEntry(entry);
   }
   popFirst() {
-    return popFirstEntry(this.state);
+    const entry = popFirstEntry(this.state);
+    if (entry === null) return null;
+    return freezeEntry(entry);
   }
   peekFirst() {
     if (this.state.entryCount === 0) {
       return null;
     }
-    return leafEntryAt(this.state.leftmostLeaf, 0);
+    return freezeEntry(leafEntryAt(this.state.leftmostLeaf, 0));
   }
   peekLast() {
     if (this.state.entryCount === 0) {
       return null;
     }
     const leaf = this.state.rightmostLeaf;
-    return leafEntryAt(leaf, leafEntryCount(leaf) - 1);
+    return freezeEntry(leafEntryAt(leaf, leafEntryCount(leaf) - 1));
   }
   popLast() {
-    return popLastEntry(this.state);
+    const entry = popLastEntry(this.state);
+    if (entry === null) return null;
+    return freezeEntry(entry);
   }
   clear() {
     const emptyLeaf = createLeafNode([], null);
@@ -1710,16 +2070,9 @@ var InMemoryBTree = class _InMemoryBTree {
     this.state.entryCount = 0;
     this.state._cursor.leaf = emptyLeaf;
     this.state._cursor.index = 0;
-    if (this.state.entryKeys !== null) {
-      this.state.entryKeys.clear();
-    }
+    this.state.entryKeys?.clear();
     if (this.state.autoScale) {
-      const tier = computeAutoScaleTier(0);
-      this.state.maxLeafEntries = tier.maxLeaf;
-      this.state.maxBranchChildren = tier.maxBranch;
-      this.state.minLeafEntries = Math.ceil(tier.maxLeaf / 2);
-      this.state.minBranchChildren = Math.ceil(tier.maxBranch / 2);
-      this.state._nextAutoScaleThreshold = computeNextAutoScaleThreshold(0);
+      resetAutoScaleToTier0(this.state);
     }
   }
   get(key) {
@@ -1733,12 +2086,12 @@ var InMemoryBTree = class _InMemoryBTree {
   findFirst(key) {
     const found = findFirstMatchingUserKey(this.state, key);
     if (found === null) return null;
-    return leafEntryAt(found.leaf, found.index);
+    return freezeEntry(leafEntryAt(found.leaf, found.index));
   }
   findLast(key) {
     const found = findLastMatchingUserKey(this.state, key);
     if (found === null) return null;
-    return leafEntryAt(found.leaf, found.index);
+    return freezeEntry(leafEntryAt(found.leaf, found.index));
   }
   nextHigherKey(key) {
     return findNextHigherKey(this.state, key);
@@ -1749,7 +2102,7 @@ var InMemoryBTree = class _InMemoryBTree {
   getPairOrNextLower(key) {
     const found = findPairOrNextLower(this.state, key);
     if (found === null) return null;
-    return leafEntryAt(found.leaf, found.index);
+    return freezeEntry(leafEntryAt(found.leaf, found.index));
   }
   count(startKey, endKey, options) {
     return countRangeEntries(this.state, startKey, endKey, options);
@@ -1758,14 +2111,14 @@ var InMemoryBTree = class _InMemoryBTree {
     return deleteRangeEntries(this.state, startKey, endKey, options);
   }
   range(startKey, endKey, options) {
-    return rangeQueryEntries(this.state, startKey, endKey, options);
+    return rangeQueryPublicEntries(this.state, startKey, endKey, options);
   }
   *entries() {
     let leaf = this.state.leftmostLeaf;
     while (leaf !== null) {
       const count = leafEntryCount(leaf);
       for (let i = 0; i < count; i += 1) {
-        yield leafEntryAt(leaf, i);
+        yield freezeEntry(leafEntryAt(leaf, i));
       }
       leaf = leaf.next;
     }
@@ -1775,7 +2128,7 @@ var InMemoryBTree = class _InMemoryBTree {
     while (leaf !== null) {
       const count = leafEntryCount(leaf);
       for (let i = count - 1; i >= 0; i -= 1) {
-        yield leafEntryAt(leaf, i);
+        yield freezeEntry(leafEntryAt(leaf, i));
       }
       leaf = leaf.prev;
     }
@@ -1793,48 +2146,26 @@ var InMemoryBTree = class _InMemoryBTree {
   [Symbol.iterator]() {
     return this.entries();
   }
+  forEachRange(startKey, endKey, callback, options) {
+    forEachRangeEntries(this.state, startKey, endKey, callback, options);
+  }
   forEach(callback, thisArg) {
-    let leaf = this.state.leftmostLeaf;
-    while (leaf !== null) {
-      const count = leafEntryCount(leaf);
-      for (let i = 0; i < count; i += 1) {
-        callback.call(thisArg, leafEntryAt(leaf, i));
-      }
-      leaf = leaf.next;
-    }
+    forEachEntry(this.state, callback, thisArg);
   }
   snapshot() {
-    const result = new Array(this.state.entryCount);
-    let leaf = this.state.leftmostLeaf;
-    let writeIdx = 0;
-    while (leaf !== null) {
-      const count = leafEntryCount(leaf);
-      for (let i = 0; i < count; i += 1) {
-        result[writeIdx++] = leafEntryAt(leaf, i);
-      }
-      leaf = leaf.next;
-    }
-    return result;
+    return snapshotEntries(this.state);
   }
   clone() {
-    const cloned = new _InMemoryBTree(buildConfigFromState(this.state));
+    const cloned = new _InMemoryBTree(
+      buildConfigFromState(this.state)
+    );
     applyAutoScaleCapacitySnapshot(
       cloned.state,
       this.state.maxLeafEntries,
       this.state.maxBranchChildren
     );
     if (this.state.entryCount > 0) {
-      const pairs = new Array(this.state.entryCount);
-      let leaf = this.state.leftmostLeaf;
-      let writeIdx = 0;
-      while (leaf !== null) {
-        const count = leafEntryCount(leaf);
-        for (let i = 0; i < count; i += 1) {
-          pairs[writeIdx++] = leafEntryAt(leaf, i);
-        }
-        leaf = leaf.next;
-      }
-      cloned.putMany(pairs);
+      cloned.putMany(collectInternalEntries(this.state));
     }
     return cloned;
   }
@@ -1843,26 +2174,19 @@ var InMemoryBTree = class _InMemoryBTree {
   }
   static fromJSON(json, compareKeys) {
     validateBTreeJSON(json);
-    const strict = json.config.duplicateKeys !== "allow";
-    for (let i = 1; i < json.entries.length; i += 1) {
-      const cmp = compareKeys(json.entries[i - 1][0], json.entries[i][0]);
-      if (cmp > 0) {
-        throw new BTreeValidationError("fromJSON: entries not sorted.");
-      }
-      if (strict && cmp === 0) {
-        throw new BTreeValidationError(
-          'fromJSON: duplicate keys require duplicateKeys "allow".'
-        );
-      }
-    }
-    const tree = new _InMemoryBTree(buildConfigFromJSON(json, compareKeys));
+    validateBTreeJSONSortOrder(json, compareKeys);
+    const tree = new _InMemoryBTree(
+      buildConfigFromJSON(json, compareKeys)
+    );
     applyAutoScaleCapacitySnapshot(
       tree.state,
       json.config.maxLeafEntries,
       json.config.maxBranchChildren
     );
     if (json.entries.length > 0) {
-      const pairs = new Array(json.entries.length);
+      const pairs = new Array(
+        json.entries.length
+      );
       for (let i = 0; i < json.entries.length; i += 1) {
         pairs[i] = { key: json.entries[i][0], value: json.entries[i][1] };
       }