@frostpillar/frostpillar-btree 0.2.6 → 0.2.7

package/dist/index.cjs

@@ -77,11 +77,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);
   }
@@ -135,7 +136,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) => {
@@ -164,7 +172,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;
@@ -185,8 +197,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;
@@ -216,17 +236,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 toPublicEntry = (entry) => ({
-  entryId: entry.entryId,
-  key: entry.key,
-  value: entry.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;
 };
@@ -376,7 +400,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)) {
@@ -479,55 +507,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) {
@@ -537,24 +567,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) {
@@ -570,12 +658,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) => {
@@ -584,27 +669,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;
@@ -613,15 +689,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) {
@@ -629,8 +710,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);
@@ -683,7 +768,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;
@@ -702,44 +790,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);
@@ -756,6 +868,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) => {
@@ -768,16 +898,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) {
@@ -794,10 +924,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) {
@@ -825,10 +957,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)) {
@@ -874,25 +1011,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,
@@ -908,6 +1062,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 }
   };
@@ -923,7 +1078,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) {
@@ -950,6 +1107,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) => {
@@ -970,7 +1135,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) {
@@ -978,7 +1147,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);
@@ -1012,11 +1185,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;
@@ -1027,9 +1207,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");
   }
@@ -1067,7 +1250,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);
@@ -1075,42 +1261,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;
 };
@@ -1121,7 +1390,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);
@@ -1137,7 +1407,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);
@@ -1156,64 +1427,14 @@ var removeFirstMatchingEntry = (state, key) => {
   leafRemoveAt(targetLeaf, removeAt);
   state.entryCount -= 1;
   if (state.entryKeys !== null) {
-    state.entryKeys.delete(targetEntry.entryId);
-  }
-  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.");
+    state.entryKeys.delete(targetEntry.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);
-  entry.value = newValue;
-  return entry;
+  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 putManyEntries = (state, entries) => {
   if (entries.length === 0) return [];
@@ -1221,7 +1442,9 @@ var putManyEntries = (state, entries) => {
   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(
@@ -1234,7 +1457,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;
     }
@@ -1249,7 +1477,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;
@@ -1269,17 +1498,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) => {
@@ -1342,13 +1571,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;
@@ -1357,6 +1601,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)) {
@@ -1365,7 +1647,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);
@@ -1387,9 +1672,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;
 };
@@ -1449,6 +1732,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.");
@@ -1460,22 +1771,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) => {
@@ -1484,7 +1780,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;
   }
@@ -1509,7 +1807,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."
+    );
   }
 };
 
@@ -1536,7 +1836,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."
+        );
       }
     }
   }
@@ -1544,12 +1846,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.");
@@ -1558,9 +1855,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);
@@ -1582,76 +1884,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);
 };
@@ -1707,7 +2043,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) {
@@ -1715,7 +2051,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) {
@@ -1723,7 +2059,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) {
@@ -1731,30 +2067,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);
@@ -1764,16 +2100,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) {
@@ -1787,65 +2116,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;
     }
@@ -1855,7 +2158,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;
     }
@@ -1873,55 +2176,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;
   }
@@ -1930,26 +2204,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] };
       }
@@ -1993,13 +2260,17 @@ var assertNeverMutation = (mutation) => {
 var validatePutManyEntries = (entries) => {
   for (const entry of entries) {
     if (typeof entry !== "object" || entry === null || !("key" in entry) || !("value" in entry)) {
-      throw new BTreeConcurrencyError("Malformed putMany mutation: each entry must have key and value.");
+      throw new BTreeConcurrencyError(
+        "Malformed putMany mutation: each entry must have key and value."
+      );
     }
   }
 };
 var validateInitMutation = (m, expectedConfigFingerprint) => {
   if (typeof m.configFingerprint !== "string") {
-    throw new BTreeConcurrencyError("Malformed init mutation: missing configFingerprint.");
+    throw new BTreeConcurrencyError(
+      "Malformed init mutation: missing configFingerprint."
+    );
   }
   if (expectedConfigFingerprint !== void 0 && m.configFingerprint !== expectedConfigFingerprint) {
     throw new BTreeConcurrencyError(
@@ -2007,45 +2278,70 @@ var validateInitMutation = (m, expectedConfigFingerprint) => {
     );
   }
 };
-var validateSingleMutation = (m, expectedConfigFingerprint) => {
+var validateMutationFields = (m) => {
   switch (m.type) {
-    case "init":
-      validateInitMutation(m, expectedConfigFingerprint);
-      break;
     case "put":
       if (!("key" in m) || !("value" in m)) {
-        throw new BTreeConcurrencyError("Malformed put mutation: missing key or value.");
+        throw new BTreeConcurrencyError(
+          "Malformed put mutation: missing key or value."
+        );
       }
       break;
     case "remove":
       if (!("key" in m)) {
-        throw new BTreeConcurrencyError("Malformed remove mutation: missing key.");
+        throw new BTreeConcurrencyError(
+          "Malformed remove mutation: missing key."
+        );
       }
       break;
     case "removeById":
       if (!("entryId" in m)) {
-        throw new BTreeConcurrencyError("Malformed removeById mutation: missing entryId.");
+        throw new BTreeConcurrencyError(
+          "Malformed removeById mutation: missing entryId."
+        );
       }
       break;
     case "updateById":
       if (!("entryId" in m) || !("value" in m)) {
-        throw new BTreeConcurrencyError("Malformed updateById mutation: missing entryId or value.");
+        throw new BTreeConcurrencyError(
+          "Malformed updateById mutation: missing entryId or value."
+        );
       }
       break;
-    case "popFirst":
-    case "popLast":
-      break;
     case "putMany":
       if (!("entries" in m) || !Array.isArray(m.entries)) {
-        throw new BTreeConcurrencyError("Malformed putMany mutation: missing entries array.");
+        throw new BTreeConcurrencyError(
+          "Malformed putMany mutation: missing entries array."
+        );
       }
       validatePutManyEntries(m.entries);
       break;
     case "deleteRange":
       if (!("startKey" in m) || !("endKey" in m)) {
-        throw new BTreeConcurrencyError("Malformed deleteRange mutation: missing startKey or endKey.");
+        throw new BTreeConcurrencyError(
+          "Malformed deleteRange mutation: missing startKey or endKey."
+        );
       }
       break;
+    default:
+      break;
+  }
+};
+var validateSingleMutation = (m, expectedConfigFingerprint) => {
+  switch (m.type) {
+    case "init":
+      validateInitMutation(m, expectedConfigFingerprint);
+      break;
+    case "put":
+    case "remove":
+    case "removeById":
+    case "updateById":
+    case "putMany":
+    case "deleteRange":
+      validateMutationFields(m);
+      break;
+    case "popFirst":
+    case "popLast":
     case "clear":
       break;
     default:
@@ -2057,7 +2353,9 @@ var validateSingleMutation = (m, expectedConfigFingerprint) => {
 var validateMutationBatch = (mutations, expectedConfigFingerprint) => {
   for (const mutation of mutations) {
     if (typeof mutation !== "object" || mutation === null) {
-      throw new BTreeConcurrencyError("Malformed mutation: expected an object.");
+      throw new BTreeConcurrencyError(
+        "Malformed mutation: expected an object."
+      );
     }
     validateSingleMutation(
       mutation,
@@ -2092,9 +2390,7 @@ var normalizeReadMode = (value) => {
     return "strong";
   }
   if (value !== "strong" && value !== "local") {
-    throw new BTreeConcurrencyError(
-      `readMode: must be 'strong' or 'local'.`
-    );
+    throw new BTreeConcurrencyError(`readMode: must be 'strong' or 'local'.`);
   }
   return value;
 };
@@ -2144,7 +2440,11 @@ var applyMutationLocal = (tree, mutation, onInit) => {
     case "popLast":
       return tree.popLast();
     case "deleteRange":
-      return tree.deleteRange(mutation.startKey, mutation.endKey, mutation.options);
+      return tree.deleteRange(
+        mutation.startKey,
+        mutation.endKey,
+        mutation.options
+      );
     case "clear":
       tree.clear();
       return null;
@@ -2191,7 +2491,9 @@ var createPutManyEvaluator = (entries, duplicateKeys, compareKeys) => {
     for (let i = 1; i < entries.length; i += 1) {
       const cmp = 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(
@@ -2222,59 +2524,48 @@ var createClearEvaluator = () => {
   return () => ({ type: "clear" });
 };
 
-// src/concurrency/ConcurrentInMemoryBTree.ts
-var ConcurrentInMemoryBTree = class {
-  constructor(config) {
-    this.store = config.store;
-    this.compareKeys = config.compareKeys;
-    this.maxRetries = normalizeMaxRetries(config.maxRetries);
-    this.maxSyncMutationsPerBatch = normalizeMaxSyncMutationsPerBatch(
-      config.maxSyncMutationsPerBatch
+// src/concurrency/syncLogValidation.ts
+var validateSyncLog = (log, maxSyncMutationsPerBatch) => {
+  if (typeof log.version !== "bigint") {
+    throw new BTreeConcurrencyError("Store contract: version must be bigint.");
+  }
+  if (!Array.isArray(log.mutations)) {
+    throw new BTreeConcurrencyError(
+      "Store contract: mutations must be an array."
     );
-    this.duplicateKeys = config.duplicateKeys ?? "replace";
-    this.readMode = normalizeReadMode(config.readMode);
-    this.configFingerprint = computeConfigFingerprint(config);
-    this.tree = new InMemoryBTree({
-      compareKeys: config.compareKeys,
-      maxLeafEntries: config.maxLeafEntries,
-      maxBranchChildren: config.maxBranchChildren,
-      duplicateKeys: config.duplicateKeys,
-      enableEntryIdLookup: config.enableEntryIdLookup,
-      autoScale: config.autoScale
-    });
+  }
+  if (log.mutations.length > maxSyncMutationsPerBatch) {
+    throw new BTreeConcurrencyError(
+      `Sync batch exceeded limit (${String(maxSyncMutationsPerBatch)}).`
+    );
+  }
+};
+
+// src/concurrency/coordinator.ts
+var Coordinator = class {
+  constructor(tree, store, maxRetries, maxSyncMutationsPerBatch, configFingerprint, readMode) {
+    this.tree = tree;
+    this.store = store;
+    this.maxRetries = maxRetries;
+    this.maxSyncMutationsPerBatch = maxSyncMutationsPerBatch;
+    this.configFingerprint = configFingerprint;
+    this.readMode = readMode;
     this.currentVersion = 0n;
     this.operationQueue = Promise.resolve();
     this.initSeen = false;
     this.corrupted = false;
   }
-  async sync() {
-    await this.runExclusive(async () => {
-      await this.syncUnlocked();
-    });
-  }
   async syncUnlocked() {
     const log = await this.store.getLogEntriesSince(this.currentVersion);
-    if (typeof log.version !== "bigint") {
-      throw new BTreeConcurrencyError("Store contract: version must be bigint.");
-    }
-    if (!Array.isArray(log.mutations)) {
-      throw new BTreeConcurrencyError("Store contract: mutations must be an array.");
-    }
-    if (log.mutations.length > this.maxSyncMutationsPerBatch) {
-      throw new BTreeConcurrencyError(
-        `Sync batch exceeded limit (${String(this.maxSyncMutationsPerBatch)}).`
-      );
-    }
-    if (log.version <= this.currentVersion) {
-      return;
-    }
+    validateSyncLog(log, this.maxSyncMutationsPerBatch);
+    if (log.version <= this.currentVersion) return;
     validateMutationBatch(log.mutations, this.configFingerprint);
     try {
-      for (const mutation of log.mutations) {
-        applyMutationLocal(this.tree, mutation, () => {
-          this.initSeen = true;
-        });
-      }
+      const markInit = () => {
+        this.initSeen = true;
+      };
+      for (const mutation of log.mutations)
+        applyMutationLocal(this.tree, mutation, markInit);
       this.currentVersion = log.version;
     } catch (error) {
       this.corrupted = true;
@@ -2286,11 +2577,10 @@ var ConcurrentInMemoryBTree = class {
   }
   runExclusive(operation) {
     const run = async () => {
-      if (this.corrupted) {
+      if (this.corrupted)
         throw new BTreeConcurrencyError(
           "Instance is permanently corrupted. Discard and create a new instance."
         );
-      }
       return operation();
     };
     const result = this.operationQueue.then(run, run);
@@ -2302,40 +2592,38 @@ var ConcurrentInMemoryBTree = class {
   }
   readOp(fn) {
     return this.runExclusive(async () => {
-      if (this.readMode === "strong") {
-        await this.syncUnlocked();
-      }
+      if (this.readMode === "strong") await this.syncUnlocked();
       return fn(this.tree);
     });
   }
-  async appendMutationAndApplyUnlocked(evaluate) {
+  async appendAndApply(evaluate) {
     for (let attempt = 0; attempt < this.maxRetries; attempt += 1) {
       await this.syncUnlocked();
       const mutation = evaluate(this.tree);
-      if (mutation === null) {
-        return null;
-      }
+      if (mutation === null) return null;
       const expectedVersion = this.currentVersion;
-      const mutations = this.initSeen ? [mutation] : [{ type: "init", configFingerprint: this.configFingerprint }, mutation];
+      const mutations = this.initSeen ? [mutation] : [
+        { type: "init", configFingerprint: this.configFingerprint },
+        mutation
+      ];
       const appendResult = await this.store.append(expectedVersion, mutations);
       assertAppendVersionContract(expectedVersion, appendResult);
       if (appendResult.applied) {
         try {
+          const markInit = () => {
+            this.initSeen = true;
+          };
           for (const m of mutations) {
             if (m === mutation) break;
-            applyMutationLocal(this.tree, m, () => {
-              this.initSeen = true;
-            });
+            applyMutationLocal(this.tree, m, markInit);
           }
-          const localResult = applyMutationLocal(
+          const result = applyMutationLocal(
             this.tree,
             mutation,
-            () => {
-              this.initSeen = true;
-            }
+            markInit
           );
           this.currentVersion = appendResult.version;
-          return localResult;
+          return result;
         } catch (error) {
           this.corrupted = true;
           const cause = error instanceof Error ? error.message : String(error);
@@ -2349,137 +2637,159 @@ var ConcurrentInMemoryBTree = class {
       `Mutation failed after ${String(this.maxRetries)} retries.`
     );
   }
-  async put(key, value) {
-    return this.runExclusive(async () => {
-      return this.appendMutationAndApplyUnlocked(
-        createPutEvaluator(this.duplicateKeys, key, value)
-      );
+  writeOp(evaluator) {
+    return this.runExclusive(async () => this.appendAndApply(evaluator));
+  }
+};
+
+// src/concurrency/ConcurrentInMemoryBTree.ts
+var ConcurrentInMemoryBTree = class {
+  constructor(config) {
+    this.compareKeys = config.compareKeys;
+    this.duplicateKeys = config.duplicateKeys ?? "replace";
+    const tree = new InMemoryBTree({
+      compareKeys: config.compareKeys,
+      maxLeafEntries: config.maxLeafEntries,
+      maxBranchChildren: config.maxBranchChildren,
+      duplicateKeys: config.duplicateKeys,
+      enableEntryIdLookup: config.enableEntryIdLookup,
+      autoScale: config.autoScale,
+      deleteRebalancePolicy: config.deleteRebalancePolicy
     });
+    this.coord = new Coordinator(
+      tree,
+      config.store,
+      normalizeMaxRetries(config.maxRetries),
+      normalizeMaxSyncMutationsPerBatch(config.maxSyncMutationsPerBatch),
+      computeConfigFingerprint(config),
+      normalizeReadMode(config.readMode)
+    );
   }
-  async remove(key) {
-    return this.runExclusive(async () => {
-      return this.appendMutationAndApplyUnlocked(createRemoveEvaluator(key));
+  async sync() {
+    await this.coord.runExclusive(async () => {
+      await this.coord.syncUnlocked();
     });
   }
-  async removeById(entryId) {
-    return this.runExclusive(async () => {
-      return this.appendMutationAndApplyUnlocked(createRemoveByIdEvaluator(entryId));
+  async syncThenRead(fn) {
+    return this.coord.runExclusive(async () => {
+      await this.coord.syncUnlocked();
+      return fn(this.coord.tree);
     });
   }
+  async put(key, value) {
+    return this.coord.writeOp(
+      createPutEvaluator(this.duplicateKeys, key, value)
+    );
+  }
+  async remove(key) {
+    return this.coord.writeOp(createRemoveEvaluator(key));
+  }
+  async removeById(entryId) {
+    return this.coord.writeOp(createRemoveByIdEvaluator(entryId));
+  }
   async updateById(entryId, value) {
-    return this.runExclusive(async () => {
-      return this.appendMutationAndApplyUnlocked(createUpdateByIdEvaluator(entryId, value));
-    });
+    return this.coord.writeOp(createUpdateByIdEvaluator(entryId, value));
   }
   async popFirst() {
-    return this.runExclusive(async () => {
-      return this.appendMutationAndApplyUnlocked(createPopFirstEvaluator());
-    });
+    return this.coord.writeOp(createPopFirstEvaluator());
   }
   async popLast() {
-    return this.runExclusive(async () => {
-      return this.appendMutationAndApplyUnlocked(createPopLastEvaluator());
-    });
+    return this.coord.writeOp(createPopLastEvaluator());
   }
   async putMany(entries) {
-    if (entries.length === 0) {
-      return [];
-    }
-    return this.runExclusive(async () => {
-      return this.appendMutationAndApplyUnlocked(
-        createPutManyEvaluator(entries, this.duplicateKeys, this.compareKeys)
-      );
-    });
+    if (entries.length === 0) return [];
+    return this.coord.writeOp(
+      createPutManyEvaluator(entries, this.duplicateKeys, this.compareKeys)
+    );
   }
   async deleteRange(startKey, endKey, options) {
-    return this.runExclusive(async () => {
-      const result = await this.appendMutationAndApplyUnlocked(
-        createDeleteRangeEvaluator(startKey, endKey, options)
-      );
-      return result ?? 0;
-    });
+    const result = await this.coord.writeOp(
+      createDeleteRangeEvaluator(startKey, endKey, options)
+    );
+    return result ?? 0;
   }
   async clear() {
-    await this.runExclusive(async () => {
-      await this.appendMutationAndApplyUnlocked(createClearEvaluator());
-    });
+    await this.coord.writeOp(createClearEvaluator());
   }
   async get(key) {
-    return this.readOp((tree) => tree.get(key));
+    return this.coord.readOp((t) => t.get(key));
   }
   async hasKey(key) {
-    return this.readOp((tree) => tree.hasKey(key));
+    return this.coord.readOp((t) => t.hasKey(key));
   }
   async findFirst(key) {
-    return this.readOp((tree) => tree.findFirst(key));
+    return this.coord.readOp((t) => t.findFirst(key));
   }
   async findLast(key) {
-    return this.readOp((tree) => tree.findLast(key));
+    return this.coord.readOp((t) => t.findLast(key));
   }
   async range(startKey, endKey, options) {
-    return this.readOp((tree) => tree.range(startKey, endKey, options));
+    return this.coord.readOp((t) => t.range(startKey, endKey, options));
   }
   async snapshot() {
-    return this.readOp((tree) => tree.snapshot());
+    return this.coord.readOp((t) => t.snapshot());
   }
   async size() {
-    return this.readOp((tree) => tree.size());
+    return this.coord.readOp((t) => t.size());
   }
   async assertInvariants() {
-    await this.readOp((tree) => tree.assertInvariants());
+    await this.coord.readOp((t) => t.assertInvariants());
   }
   async getStats() {
-    return this.readOp((tree) => tree.getStats());
+    return this.coord.readOp((t) => t.getStats());
   }
   async peekFirst() {
-    return this.readOp((tree) => tree.peekFirst());
+    return this.coord.readOp((t) => t.peekFirst());
   }
   async peekLast() {
-    return this.readOp((tree) => tree.peekLast());
+    return this.coord.readOp((t) => t.peekLast());
   }
   async peekById(entryId) {
-    return this.readOp((tree) => tree.peekById(entryId));
+    return this.coord.readOp((t) => t.peekById(entryId));
   }
   async count(startKey, endKey, options) {
-    return this.readOp((tree) => tree.count(startKey, endKey, options));
+    return this.coord.readOp((t) => t.count(startKey, endKey, options));
   }
   async nextHigherKey(key) {
-    return this.readOp((tree) => tree.nextHigherKey(key));
+    return this.coord.readOp((t) => t.nextHigherKey(key));
   }
   async nextLowerKey(key) {
-    return this.readOp((tree) => tree.nextLowerKey(key));
+    return this.coord.readOp((t) => t.nextLowerKey(key));
   }
   async getPairOrNextLower(key) {
-    return this.readOp((tree) => tree.getPairOrNextLower(key));
+    return this.coord.readOp((t) => t.getPairOrNextLower(key));
   }
   async entries() {
-    return this.readOp((tree) => Array.from(tree.entries()));
+    return this.coord.readOp((t) => Array.from(t.entries()));
   }
   async entriesReversed() {
-    return this.readOp((tree) => Array.from(tree.entriesReversed()));
+    return this.coord.readOp((t) => Array.from(t.entriesReversed()));
   }
   async keys() {
-    return this.readOp((tree) => Array.from(tree.keys()));
+    return this.coord.readOp((t) => Array.from(t.keys()));
   }
   async values() {
-    return this.readOp((tree) => Array.from(tree.values()));
+    return this.coord.readOp((t) => Array.from(t.values()));
   }
   async forEach(callback) {
-    await this.readOp((tree) => {
-      tree.forEach(callback);
+    await this.coord.readOp((t) => {
+      t.forEach(callback);
+    });
+  }
+  async forEachRange(startKey, endKey, callback, options) {
+    await this.coord.readOp((t) => {
+      t.forEachRange(startKey, endKey, callback, options);
     });
   }
   async *[Symbol.asyncIterator]() {
     const all = await this.entries();
-    for (const entry of all) {
-      yield entry;
-    }
+    for (const entry of all) yield entry;
   }
   async clone() {
-    return this.readOp((tree) => tree.clone());
+    return this.coord.readOp((t) => t.clone());
   }
   async toJSON() {
-    return this.readOp((tree) => tree.toJSON());
+    return this.coord.readOp((t) => t.toJSON());
   }
   static fromJSON(json, compareKeys) {
     return InMemoryBTree.fromJSON(json, compareKeys);