data-structure-typed 2.2.8 → 2.3.0

package/test/unit/data-structures/binary-tree/bst.more-branches-5.coverage.test.ts

@@ -0,0 +1,40 @@
+import { BST } from '../../../../src';
+
+describe('BST additional reachable branch coverage (batch 5)', () => {
+  it('search(): forces shouldVisitRight key-pruning branch + covers && chain short-circuit variants', () => {
+    const t = new BST<number, number>();
+    t.setMany([
+      [10, 10],
+      [20, 20]
+    ]);
+
+    const originalIsPredicate = (t as any)._isPredicate.bind(t);
+
+    const run = (keyNodeOrEntry: any) => {
+      let calls = 0;
+      (t as any)._isPredicate = (p: any) => {
+        // 1st call (isPred computation) => true, to bypass the fast-path.
+        // After that, behave like the real implementation so _ensurePredicate works
+        // and shouldVisitRight sees "not predicate".
+        calls++;
+        if (calls === 1) return true;
+        return originalIsPredicate(p);
+      };
+
+      try {
+        t.search(keyNodeOrEntry);
+      } finally {
+        (t as any)._isPredicate = originalIsPredicate;
+      }
+    };
+
+    // 1) benchmarkKey === null => hits first short-circuit (benchmarkKey !== null)
+    run([null, 0]);
+
+    // 2) benchmarkKey === undefined => passes first check, fails second
+    run([undefined, 0]);
+
+    // 3) compare(...) < 0 is false => passes both nullish checks
+    run([5, 0]);
+  });
+});

package/test/unit/data-structures/binary-tree/bst.more.coverage.test.ts

@@ -0,0 +1,39 @@
+import { BST, BSTNode, Range } from '../../../../src';
+
+describe('BST additional coverage', () => {
+  it('BSTNode.familyPosition covers MAL_NODE branch', () => {
+    const root = new BSTNode<number, number>(10);
+    const mal = new BSTNode<number, number>(5);
+    mal.parent = root;
+    // parent does not point to mal via left/right
+    expect(mal.familyPosition).toBe('MAL_NODE');
+  });
+
+  it('getNode returns undefined for null/undefined, and handles runtime Range input', () => {
+    const bst = new BST<number, number>();
+    bst.set(2, 2);
+
+    expect(bst.getNode(undefined as any)).toBeUndefined();
+    expect(bst.getNode(null as any)).toBeUndefined();
+
+    const r = new Range<number>(2, 2, true, true);
+    expect(bst.getNode(r as any)?.key).toBe(2);
+  });
+
+  it('getNodes returns [] for null/undefined and ignores entry with null key', () => {
+    const bst = new BST<number, number>([2, 1, 3]);
+
+    expect(bst.getNodes(undefined as any)).toEqual([]);
+    expect(bst.getNodes(null as any)).toEqual([]);
+
+    // entry with null key => targetKey undefined => []
+    expect(bst.getNodes([null as any, 123] as any)).toEqual([]);
+  });
+
+  it('getNodes returns [] when startNode is not a real node', () => {
+    const bst = new BST<number, number>([2, 1, 3]);
+
+    // ensureNode(null) => undefined => []
+    expect(bst.getNodes(2, false, null as any)).toEqual([]);
+  });
+});

package/test/unit/data-structures/binary-tree/bst.node-family.coverage.test.ts

@@ -0,0 +1,29 @@
+import { BSTNode } from '../../../../src';
+
+describe('BSTNode familyPosition coverage', () => {
+  it('covers ISOLATED/ROOT/LEFT/RIGHT/ROOT_LEFT/ROOT_RIGHT and MAL_NODE', () => {
+    const isolated = new BSTNode<number, number>(1);
+    expect(isolated.familyPosition).toBe('ISOLATED');
+
+    const root = new BSTNode<number, number>(10);
+    const left = new BSTNode<number, number>(5);
+    const right = new BSTNode<number, number>(15);
+
+    root.left = left;
+    root.right = right;
+
+    expect(root.familyPosition).toBe('ROOT');
+    expect(left.familyPosition).toBe('LEFT');
+    expect(right.familyPosition).toBe('RIGHT');
+
+    left.left = new BSTNode<number, number>(2);
+    right.right = new BSTNode<number, number>(20);
+
+    expect(left.familyPosition).toBe('ROOT_LEFT');
+    expect(right.familyPosition).toBe('ROOT_RIGHT');
+
+    const mal = new BSTNode<number, number>(999);
+    mal.parent = root;
+    expect(mal.familyPosition).toBe('MAL_NODE');
+  });
+});

package/test/unit/data-structures/binary-tree/bst.range-pruning.coverage.test.ts

@@ -0,0 +1,43 @@
+import { BST, Range } from '../../../../src';
+
+describe('BST range/pruning coverage', () => {
+  it('getNodes(range) covers includeLow/includeHigh pruning branches', () => {
+    const bst = new BST<number, number>();
+    for (const k of [10, 5, 15, 3, 7, 12, 18]) bst.set(k, k);
+
+    // includeLow/includeHigh true
+    const r1 = new Range<number>(7, 12, true, true);
+    expect(bst.getNodes(r1 as any).map(n => n.key)).toEqual([7, 10, 12]);
+
+    // includeLow false (exclude 7)
+    const r2 = new Range<number>(7, 12, false, true);
+    expect(bst.getNodes(r2 as any).map(n => n.key)).toEqual([10, 12]);
+
+    // includeHigh false (exclude 12)
+    const r3 = new Range<number>(7, 12, true, false);
+    expect(bst.getNodes(r3 as any).map(n => n.key)).toEqual([7, 10]);
+
+    // exclude both ends
+    const r4 = new Range<number>(7, 12, false, false);
+    expect(bst.getNodes(r4 as any).map(n => n.key)).toEqual([10]);
+  });
+
+  it('getNodes(predicate) exercises predicate-search shouldVisitLeft/Right fallthrough', () => {
+    const bst = new BST<number, number>();
+    for (const k of [4, 2, 6, 1, 3, 5, 7]) bst.set(k, k);
+
+    // Predicate that matches only leaf nodes, to force traversal and filtering.
+    const nodes = bst.getNodes(node => !bst.isRealNode(node.left) && !bst.isRealNode(node.right));
+    expect(nodes.map(n => n.key).sort((a, b) => a - b)).toEqual([1, 3, 5, 7]);
+
+    // onlyOne=true should early-exit after first match (in-order => 1)
+    const one = bst.getNodes(node => !bst.isRealNode(node.left) && !bst.isRealNode(node.right), true);
+    expect(one).toHaveLength(1);
+    expect(one[0].key).toBe(1);
+  });
+
+  it('rangeSearch overload [low, high] is accepted', () => {
+    const bst = new BST<number, number>([10, 5, 15, 3, 7, 12, 18]);
+    expect(bst.rangeSearch([7, 12])).toEqual([7, 10, 12]);
+  });
+});

package/test/unit/data-structures/binary-tree/bst.search-fastpath.coverage.test.ts

@@ -0,0 +1,30 @@
+import { BST } from '../../../../src';
+
+describe('BST search() fast-path coverage', () => {
+  it('search(node) uses node.key extraction branch and returns callback result', () => {
+    const t = new BST<number, string>([], { isMapMode: false });
+    t.set(10, 'a');
+    t.set(5, 'b');
+    t.set(15, 'c');
+
+    const n5 = t.getNode(5)!;
+    const out = t.search(n5, false, (n: any) => n.value);
+    expect(out).toEqual(['b']);
+  });
+
+  it('search(entry) with null key returns [] (covers entry null-key guard in fast path)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15]) t.set(k, k);
+
+    const out = t.search([null as any, 1] as any);
+    expect(out).toEqual([]);
+  });
+
+  it('search by key returns [] when startNode ensureNode fails', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15]) t.set(k, k);
+
+    const out = t.search(10 as any, false, (n: any) => n.key, null as any);
+    expect(out).toEqual([]);
+  });
+});

package/test/unit/data-structures/binary-tree/bst.test.ts

@@ -1,8 +1,17 @@
 import { BST, BSTNode, IBinaryTree, Range } from '../../../../src';
 import { isDebugTest, isTestStackOverflow, SYSTEM_MAX_CALL_STACK } from '../../../config';
+import { withMutedConsole } from '../../../utils/patch';
 
 const isDebug = isDebugTest;
 
+function expectSingleDeleteResult<K, V>(removed: any, expectedKey: K) {
+  // Most tree delete APIs here return an array of { deleted, ... }.
+  expect(removed).toBeInstanceOf(Array);
+  expect(removed[0]).toBeDefined();
+  expect(removed[0].deleted).toBeDefined();
+  if (removed[0].deleted) expect(removed[0].deleted.key).toBe(expectedKey);
+}
+
 describe('BST operations test', () => {
   it('should add undefined and null', () => {
     const bst = new BST<number, string>();
@@ -115,114 +124,74 @@ describe('BST operations test', () => {
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
 
     const removed11 = bst.delete(11);
-    expect(removed11).toBeInstanceOf(Array);
-    expect(removed11[0]).toBeDefined();
-    expect(removed11[0].deleted).toBeDefined();
-
-    if (removed11[0].deleted) expect(removed11[0].deleted.key).toBe(11);
+    expectSingleDeleteResult(removed11, 11);
 
     expect(bst.isAVLBalanced()).toBe(true);
 
     expect(bst.getHeight(15)).toBe(1);
 
     const removed1 = bst.delete(1);
-    expect(removed1).toBeInstanceOf(Array);
-    expect(removed1[0]).toBeDefined();
-    expect(removed1[0].deleted).toBeDefined();
-    if (removed1[0].deleted) expect(removed1[0].deleted.key).toBe(1);
+    expectSingleDeleteResult(removed1, 1);
 
     expect(bst.isAVLBalanced()).toBe(true);
 
     expect(bst.getHeight()).toBe(4);
 
     const removed4 = bst.delete(4);
-    expect(removed4).toBeInstanceOf(Array);
-    expect(removed4[0]).toBeDefined();
-    expect(removed4[0].deleted).toBeDefined();
-    if (removed4[0].deleted) expect(removed4[0].deleted.key).toBe(4);
+    expectSingleDeleteResult(removed4, 4);
     expect(bst.isAVLBalanced()).toBe(true);
     expect(bst.getHeight()).toBe(4);
 
     const removed10 = bst.delete(10);
-    expect(removed10).toBeInstanceOf(Array);
-    expect(removed10[0]).toBeDefined();
-    expect(removed10[0].deleted).toBeDefined();
-    if (removed10[0].deleted) expect(removed10[0].deleted.key).toBe(10);
+    expectSingleDeleteResult(removed10, 10);
     expect(bst.isAVLBalanced()).toBe(false);
     expect(bst.getHeight()).toBe(4);
 
     const removed15 = bst.delete(15);
-    expect(removed15).toBeInstanceOf(Array);
-    expect(removed15[0]).toBeDefined();
-    expect(removed15[0].deleted).toBeDefined();
-    if (removed15[0].deleted) expect(removed15[0].deleted.key).toBe(15);
+    expectSingleDeleteResult(removed15, 15);
 
     expect(bst.isAVLBalanced()).toBe(true);
     expect(bst.getHeight()).toBe(3);
 
     const removed5 = bst.delete(5);
-    expect(removed5).toBeInstanceOf(Array);
-    expect(removed5[0]).toBeDefined();
-    expect(removed5[0].deleted).toBeDefined();
-    if (removed5[0].deleted) expect(removed5[0].deleted.key).toBe(5);
+    expectSingleDeleteResult(removed5, 5);
 
     expect(bst.isAVLBalanced()).toBe(true);
     expect(bst.getHeight()).toBe(3);
 
     const removed13 = bst.delete(13);
-    expect(removed13).toBeInstanceOf(Array);
-    expect(removed13[0]).toBeDefined();
-    expect(removed13[0].deleted).toBeDefined();
-    if (removed13[0].deleted) expect(removed13[0].deleted.key).toBe(13);
+    expectSingleDeleteResult(removed13, 13);
     expect(bst.isAVLBalanced()).toBe(true);
     expect(bst.getHeight()).toBe(3);
 
     const removed3 = bst.delete(3);
-    expect(removed3).toBeInstanceOf(Array);
-    expect(removed3[0]).toBeDefined();
-    expect(removed3[0].deleted).toBeDefined();
-    if (removed3[0].deleted) expect(removed3[0].deleted.key).toBe(3);
+    expectSingleDeleteResult(removed3, 3);
     expect(bst.isAVLBalanced()).toBe(false);
     expect(bst.getHeight()).toBe(3);
 
     const removed8 = bst.delete(8);
-    expect(removed8).toBeInstanceOf(Array);
-    expect(removed8[0]).toBeDefined();
-    expect(removed8[0].deleted).toBeDefined();
-    if (removed8[0].deleted) expect(removed8[0].deleted.key).toBe(8);
+    expectSingleDeleteResult(removed8, 8);
     expect(bst.isAVLBalanced()).toBe(true);
     expect(bst.getHeight()).toBe(3);
 
     const removed6 = bst.delete(6);
-    expect(removed6).toBeInstanceOf(Array);
-    expect(removed6[0]).toBeDefined();
-    expect(removed6[0].deleted).toBeDefined();
-    if (removed6[0].deleted) expect(removed6[0].deleted.key).toBe(6);
+    expectSingleDeleteResult(removed6, 6);
     expect(bst.delete(6).length).toBe(0);
     expect(bst.isAVLBalanced()).toBe(false);
     expect(bst.getHeight()).toBe(3);
 
     const removed7 = bst.delete(7);
-    expect(removed7).toBeInstanceOf(Array);
-    expect(removed7[0]).toBeDefined();
-    expect(removed7[0].deleted).toBeDefined();
-    if (removed7[0].deleted) expect(removed7[0].deleted.key).toBe(7);
+    expectSingleDeleteResult(removed7, 7);
     expect(bst.isAVLBalanced()).toBe(false);
     expect(bst.getHeight()).toBe(3);
 
     const removed9 = bst.delete(9);
-    expect(removed9).toBeInstanceOf(Array);
-    expect(removed9[0]).toBeDefined();
-    expect(removed9[0].deleted).toBeDefined();
-    if (removed9[0].deleted) expect(removed9[0].deleted.key).toBe(9);
+    expectSingleDeleteResult(removed9, 9);
     expect(bst.isAVLBalanced()).toBe(false);
     expect(bst.getHeight()).toBe(3);
 
     const removed14 = bst.delete(14);
-    expect(removed14).toBeInstanceOf(Array);
-    expect(removed14[0]).toBeDefined();
-    expect(removed14[0].deleted).toBeDefined();
-    if (removed14[0].deleted) expect(removed14[0].deleted.key).toBe(14);
+    expectSingleDeleteResult(removed14, 14);
     expect(bst.isAVLBalanced()).toBe(false);
     expect(bst.getHeight()).toBe(2);
 
@@ -3300,11 +3269,12 @@ describe('BST Comparator Tests', () => {
 });
 
 describe('classic use', () => {
-  it('@example basic BST creation and add operation', () => {
+  it('@example basic BST creation and add operation', async () => {
     // Create a simple BST with numeric keys
     const bst = new BST<number>([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
 
-    bst.print();
+    // Keep the example output in source comments but avoid noisy test logs.
+    await withMutedConsole(() => bst.print());
     //         _______8__________
     //        /                  \
     //     ___4___          ____12_____

package/test/unit/data-structures/binary-tree/red-black-tree.boundary-corruption-repair.coverage.test.ts

@@ -0,0 +1,66 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree boundary corruption repair coverage', () => {
+  it('min-attach: when header._right is corrupted to NIL, branch mirrors max cache to new min', () => {
+    let tree: RedBlackTree<number, number> = new RedBlackTree<number>();
+    let active = false;
+    let flipped = false;
+    const comparator = (a: number, b: number) => {
+      // Flip once during the boundary pre-check, before the attach happens.
+      if (active && !flipped && tree) {
+        flipped = true;
+        (tree as any)._header._right = tree.NIL;
+      }
+      return a - b;
+    };
+
+    tree = new RedBlackTree<number, number>([], { isMapMode: false, comparator });
+    tree.set(10, 10);
+    tree.set(5, 5);
+    tree.set(15, 15);
+
+    // Boundary insert smaller than current min.
+    active = true;
+    tree.set(1, 1);
+    active = false;
+
+    // Repair branch should have mirrored max cache when header._right was NIL.
+    expect((tree as any)._header._right.key).toBe(1);
+
+    // Restore correct max cache so subsequent tests/users aren't affected.
+    const root = (tree as any)._root;
+    (tree as any)._setMaxCache(tree.isRealNode(root) ? tree.getRightMost((n: any) => n, root) : undefined);
+    expect((tree as any)._header._right.key).toBe(15);
+  });
+
+  it('max-attach: when header._left is corrupted to NIL, branch initializes min cache during max attach', () => {
+    let tree: RedBlackTree<number, number> = new RedBlackTree<number>();;
+    let active = false;
+    let flipped = false;
+    const comparator = (a: number, b: number) => {
+      if (active && !flipped && tree) {
+        flipped = true;
+        (tree as any)._header._left = tree.NIL;
+      }
+      return a - b;
+    };
+
+    tree = new RedBlackTree<number, number>([], { isMapMode: false, comparator });
+    tree.set(10, 10);
+    tree.set(5, 5);
+    tree.set(15, 15);
+
+    // Boundary insert larger than current max.
+    active = true;
+    tree.set(100, 100);
+    active = false;
+
+    // Observe the branch effect before repairing (min cache got initialized).
+    expect((tree as any)._header._left.key).toBe(100);
+
+    // Restore correct min cache.
+    const root = (tree as any)._root;
+    (tree as any)._setMinCache(tree.isRealNode(root) ? tree.getLeftMost((n: any) => n, root) : undefined);
+    expect((tree as any)._header._left.key).toBe(5);
+  });
+});

package/test/unit/data-structures/binary-tree/red-black-tree.boundary-max-update.coverage.test.ts

@@ -0,0 +1,18 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree boundary max update coverage', () => {
+  it('mapMode: updating existing max key with defined value hits store.set branch in cMax===0 fast-path', () => {
+    const t = new RedBlackTree<number, string>(); // mapMode default
+
+    t.set(10, 'mid');
+    t.set(5, 'min');
+    t.set(15, 'max');
+
+    // Update existing max key with a defined value.
+    t.set(15, 'max2');
+
+    expect(t.get(15)).toBe('max2');
+    // Assert store updated (fast-path uses store.set).
+    expect((t as any)._store.get(15)).toBe('max2');
+  });
+});

package/test/unit/data-structures/binary-tree/red-black-tree.boundary-null.coverage.test.ts

@@ -0,0 +1,53 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree boundary attach null/undefined coverage', () => {
+  it('min boundary attach works when min.left is null', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    t.set(10, 10);
+    t.set(5, 5);
+
+    const minNode = t.getNode(5)!;
+    // Force the boundary condition to treat left as empty via null.
+    (minNode as any)._left = null;
+
+    t.set(1, 1);
+
+    expect(t.getNode(1)?.parent?.key).toBe(5);
+    expect((t as any)._header._left.key).toBe(1);
+  });
+
+  it('min boundary attach works when min.left is undefined', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    t.set(10, 10);
+    t.set(5, 5);
+
+    const minNode = t.getNode(5)!;
+    // Force the boundary condition to treat left as empty via undefined.
+    (minNode as any)._left = undefined;
+
+    t.set(1, 1);
+
+    expect(t.getNode(1)?.parent?.key).toBe(5);
+    expect((t as any)._header._left.key).toBe(1);
+  });
+
+  it('max boundary attach works when max.right is null/undefined', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    t.set(10, 10);
+    t.set(15, 15);
+
+    const maxNode = t.getNode(15)!;
+    // First cover null.
+    (maxNode as any)._right = null;
+    t.set(20, 20);
+    expect(t.getNode(20)?.parent?.key).toBe(15);
+    expect((t as any)._header._right.key).toBe(20);
+
+    // Now cover undefined on the new max.
+    const maxNode2 = t.getNode(20)!;
+    (maxNode2 as any)._right = undefined;
+    t.set(25, 25);
+    expect(t.getNode(25)?.parent?.key).toBe(20);
+    expect((t as any)._header._right.key).toBe(25);
+  });
+});

package/test/unit/data-structures/binary-tree/red-black-tree.boundary-stale-cache.coverage.test.ts

@@ -0,0 +1,25 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree boundary attach stale cache coverage', () => {
+  it('boundary max attach repairs stale min cache when header._left === NIL', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    t.set(10, 10);
+    t.set(5, 5);
+
+    const NIL = (t as any).NIL;
+
+    // Stale min cache: header._left is NIL, but tree is non-empty.
+    (t as any)._header._left = NIL;
+
+    // Insert new maximum; should take boundary max attach path and hit:
+    // if (header._left === NIL) this._setMinCache(newNode)
+    t.set(20, 20);
+
+    expect((t as any)._header._right.key).toBe(20);
+    expect((t as any)._header._left).not.toBe(NIL);
+
+    // Under stale/corrupted cache conditions, the boundary fast path mirrors min to the inserted node.
+    // (In normal operation header._left would not be NIL when the tree is non-empty.)
+    expect((t as any)._header._left.key).toBe(20);
+  });
+});

package/test/unit/data-structures/binary-tree/red-black-tree.boundary-update.coverage.test.ts

@@ -0,0 +1,23 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree boundary update coverage', () => {
+  it('updating existing min/max via boundary cache fast paths does not change size', () => {
+    const t = new RedBlackTree<number, string>([], { isMapMode: false });
+
+    t.set(10, 'a');
+    t.set(5, 'min');
+    t.set(15, 'max');
+
+    const size0 = t.size;
+
+    // Update existing min key: should hit cMin===0 fast-path.
+    expect(t.set(5, 'min2')).toBe(true);
+    expect(t.size).toBe(size0);
+    expect(t.getNode(5)?.value).toBe('min2');
+
+    // Update existing max key: should hit cMax===0 fast-path.
+    expect(t.set(15, 'max2')).toBe(true);
+    expect(t.size).toBe(size0);
+    expect(t.getNode(15)?.value).toBe('max2');
+  });
+});

package/test/unit/data-structures/binary-tree/red-black-tree.cache-delete.coverage.test.ts

@@ -0,0 +1,49 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree delete cache fallback coverage', () => {
+  it('forces min/max fallback recomputation branches after deleting min/max', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15, 3, 7, 12, 18]) t.set(k, k);
+
+    // Delete current min and max to set willDeleteMin/Max paths.
+    const NIL = (t as any).NIL;
+    const minNode = (t as any)._header._left;
+    const maxNode = (t as any)._header._right;
+    expect(minNode).not.toBe(NIL);
+    expect(maxNode).not.toBe(NIL);
+    const minKey = minNode.key as number;
+    const maxKey = maxNode.key as number;
+
+    // After first delete, corrupt caches so fallback recompute branches run.
+    t.delete(minKey);
+    (t as any)._minNode = undefined;
+
+    // Delete max and also corrupt max cache.
+    t.delete(maxKey);
+    (t as any)._maxNode = undefined;
+
+    // Trigger an additional delete to enter the cache-update block with size>0.
+    t.delete(10);
+
+    // Should still have correct header min/max after recomputation.
+    const keys = [...t].map(([k]) => k).sort((a, b) => a - b);
+    if (keys.length > 0) {
+      expect((t as any)._header._left.key).toBe(keys[0]);
+      expect((t as any)._header._right.key).toBe(keys[keys.length - 1]);
+    }
+  });
+
+  it('size<=0 branch clears min/max caches', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    t.set(1, 1);
+
+    t.delete(1);
+
+    expect(t.size).toBe(0);
+    // expect(t.min).toBeUndefined();
+    // expect(t.max).toBeUndefined();
+    const NIL = (t as any).NIL;
+    expect((t as any)._header._left).toBe(NIL);
+    expect((t as any)._header._right).toBe(NIL);
+  });
+});

package/test/unit/data-structures/binary-tree/red-black-tree.cache-edge.coverage.test.ts

@@ -0,0 +1,37 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree cache edge coverage', () => {
+  it('boundary min attach updates max cache when header._right is stale NIL', () => {
+    const t = new RedBlackTree<number, number>();
+    t.set(10, 10);
+
+    // Simulate stale max cache.
+    const NIL = (t as any).NIL;
+    (t as any)._header._right = NIL;
+
+    // Insert smaller than current min; min has no left -> boundary min attach path.
+    t.set(5, 5);
+
+    // After insertion, max cache should not remain NIL.
+    expect((t as any)._header._right).not.toBe(NIL);
+    expect((t as any)._maxNode).toBeDefined();
+    expect((t as any)._header._right).toBe((t as any)._maxNode);
+  });
+
+  it('boundary max attach updates min cache when header._left is stale NIL', () => {
+    const t = new RedBlackTree<number, number>();
+    t.set(10, 10);
+
+    // Simulate stale min cache.
+    const NIL = (t as any).NIL;
+    (t as any)._header._left = NIL;
+
+    // Insert greater than current max; max has no right -> boundary max attach path.
+    t.set(15, 15);
+
+    // After insertion, min cache should not remain NIL.
+    expect((t as any)._header._left).not.toBe(NIL);
+    expect((t as any)._minNode).toBeDefined();
+    expect((t as any)._header._left).toBe((t as any)._minNode);
+  });
+});

package/test/unit/data-structures/binary-tree/red-black-tree.cache-stale-insert.coverage.test.ts

@@ -0,0 +1,39 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree stale cache insert coverage', () => {
+  it('stale header min/max caches trigger comparison-based cache repair on insertion', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    t.set(10, 10);
+    t.set(5, 5);
+    t.set(15, 15);
+
+    const n10 = t.getNode(10)!;
+
+    // Corrupt caches to point at an interior node.
+    (t as any)._header._left = n10;
+    (t as any)._header._right = n10;
+
+    // Insert a new min (not a boundary attach, because min cache is stale and minN.left is real).
+    t.set(1, 1);
+    expect((t as any)._header._left.key).toBe(1);
+
+    // Re-corrupt and insert a new max.
+    (t as any)._header._left = n10;
+    (t as any)._header._right = n10;
+
+    t.set(20, 20);
+    expect((t as any)._header._right.key).toBe(20);
+  });
+
+  it('mapMode update with undefined value does not take store-fast-path (no throw)', () => {
+    const t = new RedBlackTree<number, string>([], { isMapMode: true });
+    t.set(1, 'a');
+    expect(t.get(1)).toBe('a');
+
+    // nextValue is undefined => should bypass map-mode store.has fast-path
+    // and go through normal set logic.
+    t.set(1, undefined as any);
+    // Existing semantics: undefined does not overwrite stored value in mapMode.
+    expect(t.get(1)).toBe('a');
+  });
+});