@frostpillar/frostpillar-btree 0.2.6 → 0.2.7

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

@@ -47,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);
   }
@@ -105,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) => {
@@ -134,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;
@@ -155,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;
@@ -186,17 +206,21 @@ var normalizeDuplicateKeyPolicy = (value) => {
     return "replace";
   }
   if (value !== "allow" && value !== "reject" && value !== "replace") {
-    throw new BTreeValidationError(
-      `Invalid duplicateKeys option.`
-    );
+    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 toPublicEntry = (entry) => ({
-  entryId: entry.entryId,
-  key: entry.key,
-  value: entry.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;
 };
@@ -346,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)) {
@@ -449,55 +477,57 @@ var countRangeEntries = (state, startKey, endKey, options) => {
       cursorIndex = 0;
       continue;
     }
-    const lastEntry = leafEntryAt(cursorLeaf, leafCount - 1);
-    const cmpLast = compare(lastEntry.key, endKey);
-    if (upperExclusive ? cmpLast < 0 : cmpLast <= 0) {
+    const lastKey = leafEntryAt(cursorLeaf, leafCount - 1).key;
+    if (isLastEntryInRange(lastKey, endKey, compare, upperExclusive)) {
       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;
+    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, 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);
+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 appendLeafSlice = (leaf, from, to, output, useIndexed, writeIdx) => {
+var appendLeafSlicePublic = (leaf, from, to, output, useIndexed, writeIdx) => {
   if (useIndexed) {
     for (let i = from; i < to; i += 1) {
-      output[writeIdx++] = leafEntryAt(leaf, i);
+      output[writeIdx++] = freezeEntry(leafEntryAt(leaf, i));
     }
   } else {
     for (let i = from; i < to; i += 1) {
-      output.push(leafEntryAt(leaf, i));
+      output.push(freezeEntry(leafEntryAt(leaf, i)));
     }
   }
   return writeIdx;
 };
-var rangeQueryEntries = (state, startKey, endKey, options) => {
-  const cursor = initRangeCursor(state, startKey, endKey, options);
-  if (cursor === null) return [];
+var collectPublicEntries = (state, cursor, endKey, output) => {
+  const { compare, upperExclusive } = cursor;
   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) {
@@ -507,24 +537,82 @@ var rangeQueryEntries = (state, startKey, endKey, options) => {
       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);
+    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 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;
+    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.ts
+// src/btree/rebalance-branch.ts
 var updateMinKeyInAncestors = (node) => {
   let current = node;
   while (current.parent !== null) {
@@ -540,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) => {
@@ -554,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;
@@ -583,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) {
@@ -599,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);
@@ -653,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;
@@ -672,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);
@@ -726,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) => {
@@ -738,16 +868,16 @@ 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;
+  const lastEntry = leafEntryAt(leaf, count - 1);
+  const cmpLast = state.compareKeys(lastEntry.key, endKey);
+  if (upperExclusive ? cmpLast < 0 : cmpLast <= 0) {
+    return count;
   }
-  return removeEnd;
+  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) => {
   if (state.entryKeys !== null) {
@@ -764,10 +894,12 @@ var spliceLeafAndRebalance = (state, leaf, idx, removeCount) => {
     updateMinKeyInAncestors(leaf);
   }
   const countAfterSplice = leafEntryCount(leaf);
+  const rebalThreshold = leafRebalanceThreshold(state);
   let safetyGuard = state.minLeafEntries + 4;
-  while (safetyGuard > 0 && leaf !== state.root && leafEntryCount(leaf) < state.minLeafEntries) {
+  while (safetyGuard > 0 && leaf !== state.root && leafEntryCount(leaf) < rebalThreshold) {
     rebalanceAfterLeafRemoval(state, leaf);
-    if (leaf.parent !== null && leaf.parent.children[leaf.indexInParent] !== leaf) break;
+    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) {
@@ -795,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);
+    const countAfterSplice = spliceLeafAndRebalance(
+      state,
+      leaf,
+      idx,
+      removeCount
+    );
     deleted += removeCount;
     if (removeEnd < count) break;
     if (!isLeafStillValid(state, leaf)) {
@@ -844,25 +981,42 @@ 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,
@@ -878,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 }
   };
@@ -893,7 +1048,9 @@ var maybeAutoScale = (state) => {
     state.maxBranchChildren = maxBranch;
     state.minBranchChildren = minOccupancy(maxBranch);
   }
-  state._nextAutoScaleThreshold = computeNextAutoScaleThreshold(state.entryCount);
+  state._nextAutoScaleThreshold = computeNextAutoScaleThreshold(
+    state.entryCount
+  );
 };
 var applyAutoScaleCapacitySnapshot = (state, maxLeafEntries, maxBranchChildren) => {
   if (!state.autoScale) {
@@ -920,6 +1077,14 @@ var applyAutoScaleCapacitySnapshot = (state, maxLeafEntries, maxBranchChildren)
   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
 var computeChunkBoundaries = (total, max, min) => {
@@ -940,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) {
@@ -948,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);
@@ -982,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;
@@ -997,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");
   }
@@ -1037,7 +1220,10 @@ var splitLeaf = (state, leaf) => {
 var splitBranch = (state, branch) => {
   branchCompact(branch);
   const splitAt = Math.ceil(branch.children.length / 2);
-  const sibling = createBranchNode(branch.children.splice(splitAt), branch.parent);
+  const sibling = createBranchNode(
+    branch.children.splice(splitAt),
+    branch.parent
+  );
   branch.keys.splice(splitAt);
   if (branch.parent === null) {
     state.root = createBranchNode([branch, sibling], null);
@@ -1045,42 +1231,125 @@ var splitBranch = (state, branch) => {
   }
   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);
+  }
+  return entry;
+};
+
+// 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
+      };
+    }
+  }
+  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;
 };
@@ -1091,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);
@@ -1107,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);
@@ -1128,70 +1399,22 @@ 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) => {
-  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);
-  }
-  return entry;
-};
-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);
-  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 (cmp > 0) {
-      throw new BTreeValidationError("putMany: entries not in ascending order.");
+      throw new BTreeValidationError(
+        "putMany: entries not in ascending order."
+      );
     }
     if (strictlyAscending && cmp === 0) {
       throw new BTreeValidationError(
@@ -1204,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;
     }
@@ -1219,7 +1447,8 @@ var buildConfigFromState = (state) => {
     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;
@@ -1239,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) => {
@@ -1312,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;
@@ -1327,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)) {
@@ -1335,7 +1617,10 @@ 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);
@@ -1357,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;
 };
@@ -1419,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.");
@@ -1430,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) => {
@@ -1454,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;
   }
@@ -1479,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."
+    );
   }
 };
 
@@ -1506,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."
+        );
       }
     }
   }
@@ -1514,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.");
@@ -1528,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);
@@ -1552,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);
 };
@@ -1677,7 +2013,7 @@ var InMemoryBTree = class _InMemoryBTree {
   remove(key) {
     const entry = removeFirstMatchingEntry(this.state, key);
     if (entry === null) return null;
-    return toPublicEntry(entry);
+    return freezeEntry(entry);
   }
   removeById(entryId) {
     if (this.state.entryKeys === null) {
@@ -1685,7 +2021,7 @@ var InMemoryBTree = class _InMemoryBTree {
     }
     const entry = removeEntryById(this.state, entryId);
     if (entry === null) return null;
-    return toPublicEntry(entry);
+    return freezeEntry(entry);
   }
   peekById(entryId) {
     if (this.state.entryKeys === null) {
@@ -1693,7 +2029,7 @@ var InMemoryBTree = class _InMemoryBTree {
     }
     const entry = peekEntryById(this.state, entryId);
     if (entry === null) return null;
-    return toPublicEntry(entry);
+    return freezeEntry(entry);
   }
   updateById(entryId, value) {
     if (this.state.entryKeys === null) {
@@ -1701,30 +2037,30 @@ var InMemoryBTree = class _InMemoryBTree {
     }
     const entry = updateEntryById(this.state, entryId, value);
     if (entry === null) return null;
-    return toPublicEntry(entry);
+    return freezeEntry(entry);
   }
   popFirst() {
     const entry = popFirstEntry(this.state);
     if (entry === null) return null;
-    return toPublicEntry(entry);
+    return freezeEntry(entry);
   }
   peekFirst() {
     if (this.state.entryCount === 0) {
       return null;
     }
-    return toPublicEntry(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 toPublicEntry(leafEntryAt(leaf, leafEntryCount(leaf) - 1));
+    return freezeEntry(leafEntryAt(leaf, leafEntryCount(leaf) - 1));
   }
   popLast() {
     const entry = popLastEntry(this.state);
     if (entry === null) return null;
-    return toPublicEntry(entry);
+    return freezeEntry(entry);
   }
   clear() {
     const emptyLeaf = createLeafNode([], null);
@@ -1734,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 = minOccupancy(tier.maxLeaf);
-      this.state.minBranchChildren = minOccupancy(tier.maxBranch);
-      this.state._nextAutoScaleThreshold = computeNextAutoScaleThreshold(0);
+      resetAutoScaleToTier0(this.state);
     }
   }
   get(key) {
@@ -1757,65 +2086,39 @@ var InMemoryBTree = class _InMemoryBTree {
   findFirst(key) {
     const found = findFirstMatchingUserKey(this.state, key);
     if (found === null) return null;
-    return toPublicEntry(leafEntryAt(found.leaf, found.index));
+    return freezeEntry(leafEntryAt(found.leaf, found.index));
   }
-  /**
-   * Returns the last entry whose key matches `key`, or `null` if not found.
-   * Useful when `duplicateKeys` is `'allow'` and multiple entries share the same key.
-   */
   findLast(key) {
     const found = findLastMatchingUserKey(this.state, key);
     if (found === null) return null;
-    return toPublicEntry(leafEntryAt(found.leaf, found.index));
+    return freezeEntry(leafEntryAt(found.leaf, found.index));
   }
-  /**
-   * Returns the smallest key in the tree that is strictly greater than `key`,
-   * or `null` if no such key exists.
-   */
   nextHigherKey(key) {
     return findNextHigherKey(this.state, key);
   }
-  /**
-   * Returns the largest key in the tree that is strictly less than `key`,
-   * or `null` if no such key exists.
-   */
   nextLowerKey(key) {
     return findNextLowerKey(this.state, key);
   }
-  /**
-   * Returns the entry for `key` if it exists; otherwise returns the entry with
-   * the largest key strictly less than `key`. Returns `null` when the tree is
-   * empty or every key is greater than `key`.
-   */
   getPairOrNextLower(key) {
     const found = findPairOrNextLower(this.state, key);
     if (found === null) return null;
-    return toPublicEntry(leafEntryAt(found.leaf, found.index));
+    return freezeEntry(leafEntryAt(found.leaf, found.index));
   }
-  /**
-   * Returns the number of entries whose keys fall within [`startKey`, `endKey`].
-   * Pass `options` to make either bound exclusive.
-   */
   count(startKey, endKey, options) {
     return countRangeEntries(this.state, startKey, endKey, options);
   }
-  /**
-   * Deletes all entries whose keys fall within [`startKey`, `endKey`].
-   * Pass `options` to make either bound exclusive.
-   * @returns The number of entries deleted.
-   */
   deleteRange(startKey, endKey, options) {
     return deleteRangeEntries(this.state, startKey, endKey, options);
   }
   range(startKey, endKey, options) {
-    return rangeQueryEntries(this.state, startKey, endKey, options).map(toPublicEntry);
+    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 toPublicEntry(leafEntryAt(leaf, i));
+        yield freezeEntry(leafEntryAt(leaf, i));
       }
       leaf = leaf.next;
     }
@@ -1825,7 +2128,7 @@ var InMemoryBTree = class _InMemoryBTree {
     while (leaf !== null) {
       const count = leafEntryCount(leaf);
       for (let i = count - 1; i >= 0; i -= 1) {
-        yield toPublicEntry(leafEntryAt(leaf, i));
+        yield freezeEntry(leafEntryAt(leaf, i));
       }
       leaf = leaf.prev;
     }
@@ -1843,55 +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, toPublicEntry(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++] = toPublicEntry(leafEntryAt(leaf, i));
-      }
-      leaf = leaf.next;
-    }
-    return result;
+    return snapshotEntries(this.state);
   }
-  /**
-   * Returns a structurally independent `InMemoryBTree` with identical
-   * configuration and entries. The tree structure (nodes, links, entry IDs)
-   * is fully independent, but stored key and value references are shared
-   * with the source tree.
-   * Note: `EntryId` values are reassigned in the clone — IDs from the source tree are not valid for the clone.
-   */
   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;
   }
@@ -1900,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] };
       }