data-structure-typed 2.4.0 → 2.4.2

package/test/unit/data-structures/binary-tree/red-black-tree.more-branches-2.coverage.test.ts

@@ -1,121 +0,0 @@
-import { RedBlackTree, RedBlackTreeNode } from '../../../../src';
-
-describe('RedBlackTree remaining reachable branches (coverage)', () => {
-  it('mapMode updates existing MAX key with defined value via boundary cMax===0 path inside _setKVNode (covers store.set branch)', () => {
-    const t = new RedBlackTree<number, string>([], { isMapMode: true });
-    t.set(1, 'a');
-    t.set(2, 'b');
-
-    // Bypass _setKV store.has fast-path by corrupting the store (node exists but store.has(key) is false).
-    (t as any)._store.delete(2);
-
-    // key==max => boundary cMax===0 update in _setKVNode
-    t.set(2, 'bb');
-    expect(t.get(2)).toBe('bb');
-  });
-
-  it('mapMode updates existing interior key with defined value via normal search update branch inside _setKVNode', () => {
-    const t = new RedBlackTree<number, string>([], { isMapMode: true });
-    t.set(10, 'x');
-    t.set(5, 'a');
-    t.set(15, 'z');
-
-    // Bypass _setKV store.has fast-path for this key.
-    (t as any)._store.delete(10);
-
-    // Update a non-min/non-max key to avoid boundary min/max equality early returns.
-    t.set(10, 'xx');
-    expect(t.get(10)).toBe('xx');
-  });
-
-  it('normal-path search uses right ?? NIL fallback when a node child pointer is undefined', () => {
-    const t = new RedBlackTree<number, number>([], { isMapMode: false });
-    t.set(10, 10);
-    t.set(5, 5);
-
-    const n5 = t.getNode(5)!;
-
-    // Corrupt: right pointer becomes undefined (instead of NIL).
-    // This should exercise `current = current.right ?? NIL` fallback.
-    (n5 as any).right = undefined;
-
-    t.set(7, 7);
-    expect(t.get(7)).toBe(7);
-  });
-
-  it('setWithHintNode cache maintenance evaluates compare operands in all 4 fast-attach variants', () => {
-    // (1) c0 < 0, direct attach to hint.left
-    {
-      const t = new RedBlackTree<number, number>();
-      t.set(10, 10);
-      t.set(20, 20);
-      // Ensure caches are real nodes (not NIL)
-      (t as any)._header._left = t.getNode(10);
-      (t as any)._header._right = t.getNode(20);
-
-      const hint = t.getNode(20)!;
-      const n = t.setWithHintNode(15, 15, hint)!;
-      expect(n.key).toBe(15);
-    }
-
-    // (2) c0 < 0, attach as right child of predecessor
-    {
-      const t = new RedBlackTree<number, number>();
-      t.set(10, 10);
-      t.set(20, 20);
-      // Make hint.left real so direct attach is skipped
-      t.set(5, 5);
-      (t as any)._header._left = t.getNode(5);
-      (t as any)._header._right = t.getNode(20);
-
-      const hint = t.getNode(20)!;
-      const n = t.setWithHintNode(15, 15, hint)!;
-      expect(n.key).toBe(15);
-    }
-
-    // (3) c0 > 0, direct attach to hint.right
-    {
-      const t = new RedBlackTree<number, number>();
-      t.set(10, 10);
-      t.set(20, 20);
-      (t as any)._header._left = t.getNode(10);
-      (t as any)._header._right = t.getNode(20);
-
-      const hint = t.getNode(20)!;
-      const n = t.setWithHintNode(30, 30, hint)!;
-      expect(n.key).toBe(30);
-    }
-
-    // (4) c0 > 0, attach as left child of successor
-    {
-      const t = new RedBlackTree<number, number>();
-      t.set(10, 10);
-      t.set(30, 30);
-      t.set(20, 20);
-      // ensure hint.right is real (30) so direct attach is skipped
-      (t as any)._header._left = t.getNode(10);
-      (t as any)._header._right = t.getNode(30);
-
-      const hint = t.getNode(20)!;
-      const n = t.setWithHintNode(25, 25, hint)!;
-      expect(n.key).toBe(25);
-    }
-  });
-
-  it('_leftRotate and _rightRotate early-return when pivot or required child is missing', () => {
-    const t = new RedBlackTree<number, number>([], { isMapMode: false });
-
-    // undefined pivot
-    (t as any)._leftRotate(undefined);
-    (t as any)._rightRotate(undefined);
-
-    // pivot exists but missing required child
-    const x = new RedBlackTreeNode<number, number>(1);
-    (x as any).right = undefined;
-    const y = new RedBlackTreeNode<number, number>(2);
-    (y as any).left = undefined;
-
-    (t as any)._leftRotate(x);
-    (t as any)._rightRotate(y);
-  });
-});

package/test/unit/data-structures/binary-tree/red-black-tree.more-branches-3.coverage.test.ts

@@ -1,55 +0,0 @@
-import { RedBlackTree } from '../../../../src';
-
-describe('RedBlackTree additional reachable branch coverage (batch 3)', () => {
-  it('insertion cache: hits parent===hMax and parent===hMin else-if branches', () => {
-    const t = new RedBlackTree<number, number>();
-
-    t.set(2, 2);
-    // new max: parent should be current max
-    t.set(3, 3);
-
-    t.clear();
-
-    t.set(2, 2);
-    // new min: parent should be current min
-    t.set(1, 1);
-
-    // Sanity: min/max nodes exist and are ordered.
-    expect(t.getLeftMost((n: any) => n)?.key).toBe(1);
-    expect(t.getRightMost((n: any) => n)?.key).toBe(2);
-  });
-
-  it('setWithHintNode: executes min/max cache logical-expr second operands across all 4 ultra-fast attach variants', () => {
-    const t = new RedBlackTree<number, number>();
-
-    // Seed non-empty tree so hMin/hMax are real and `hMin===NIL || compare(...)` evaluates RHS.
-    t.setMany([
-      [10, 10],
-      [20, 20],
-      [30, 30]
-    ]);
-
-    const n10 = t.getNode(10)!;
-    const n20 = t.getNode(20)!;
-    const n30 = t.getNode(30)!;
-
-    // 1) direct attach as left of hint (new global min)
-    const n5 = t.setWithHintNode(5, 5, n10);
-    expect(n5?.key).toBe(5);
-
-    // 2) attach as right of predecessor
-    const n15 = t.setWithHintNode(15, 15, n20);
-    expect(n15?.key).toBe(15);
-
-    // 3) direct attach as right of hint (new global max)
-    const n40 = t.setWithHintNode(40, 40, n30);
-    expect(n40?.key).toBe(40);
-
-    // 4) attach as left of successor
-    const n25 = t.setWithHintNode(25, 25, n20);
-    expect(n25?.key).toBe(25);
-
-    expect(t.getLeftMost((n: any) => n)?.key).toBe(5);
-    expect(t.getRightMost((n: any) => n)?.key).toBe(40);
-  });
-});

package/test/unit/data-structures/binary-tree/red-black-tree.more-branches-4.coverage.test.ts

@@ -1,44 +0,0 @@
-import { RedBlackTree } from '../../../../src';
-
-describe('RedBlackTree additional reachable branch coverage (batch 4)', () => {
-  it('setWithHintNode: covers header._left/_right nullish-coalescing RHS (?? NIL) in all 4 ultra-fast attach variants', () => {
-    const t = new RedBlackTree<number, number>();
-
-    t.setMany([
-      [10, 10],
-      [20, 20],
-      [30, 30]
-    ]);
-
-    const n10 = t.getNode(10)!;
-    const n20 = t.getNode(20)!;
-    const n30 = t.getNode(30)!;
-
-    const clearHeaderMinMaxToUndefined = () => {
-      // Simulate a stale/partial cache state. This is a realistic “repair” scenario:
-      // the code uses `?? NIL` to tolerate undefined here.
-      (t as any)._header._left = undefined;
-      (t as any)._header._right = undefined;
-    };
-
-    // 1) direct attach as left of hint
-    clearHeaderMinMaxToUndefined();
-    expect(t.setWithHintNode(5, 5, n10)?.key).toBe(5);
-
-    // 2) attach as right of predecessor
-    clearHeaderMinMaxToUndefined();
-    expect(t.setWithHintNode(15, 15, n20)?.key).toBe(15);
-
-    // 3) direct attach as right of hint
-    clearHeaderMinMaxToUndefined();
-    expect(t.setWithHintNode(40, 40, n30)?.key).toBe(40);
-
-    // 4) attach as left of successor
-    clearHeaderMinMaxToUndefined();
-    expect(t.setWithHintNode(25, 25, n20)?.key).toBe(25);
-
-    // Sanity: tree still orders correctly.
-    expect(t.getLeftMost(n => n)?.key).toBe(5);
-    expect(t.getRightMost(n => n)?.key).toBe(40);
-  });
-});

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

@@ -1,40 +0,0 @@
-import { RedBlackTree } from '../../../../src';
-
-describe('RedBlackTree predecessor/successor coverage', () => {
-  it('covers predecessor/successor: subtree-walk, parent-climb, and undefined edges', () => {
-    const t = new RedBlackTree<number, string>([], { isMapMode: false });
-
-    // Build a tree with nodes that have (and do not have) left/right subtrees.
-    //            20
-    //         /      \
-    //       10        30
-    //     /   \     /   \
-    //    5    15   25   35
-    //        /
-    //       13
-    for (const k of [20, 10, 30, 5, 15, 25, 35, 13]) t.set(k, String(k));
-
-    const n20 = t.getNode(20)!;
-    const n15 = t.getNode(15)!;
-    const n5 = t.getNode(5)!;
-    const n35 = t.getNode(35)!;
-
-    // predecessor: has left subtree -> walk to right-most of left.
-    expect((t as any)._predecessorOf(n15)?.key).toBe(13);
-
-    // predecessor: no left subtree -> climb parents.
-    expect((t as any)._predecessorOf(n20)?.key).toBe(15);
-
-    // predecessor of min -> undefined.
-    expect((t as any)._predecessorOf(n5)).toBeUndefined();
-
-    // successor: has right subtree -> walk to left-most of right.
-    expect((t as any)._successorOf(n20)?.key).toBe(25);
-
-    // successor: no right subtree -> climb parents.
-    expect((t as any)._successorOf(n15)?.key).toBe(20);
-
-    // successor of max -> undefined.
-    expect((t as any)._successorOf(n35)).toBeUndefined();
-  });
-});

package/test/unit/data-structures/binary-tree/red-black-tree.remaining-branches.coverage.test.ts

@@ -1,123 +0,0 @@
-import { RedBlackTree } from '../../../../src';
-
-class RBTTransplantCorruptRoot extends RedBlackTree<number, number> {
-  protected override _transplant(u: any, v: any): void {
-    super._transplant(u, v);
-    // Corrupt _root only (header.parent remains canonical), so delete() fallback cond-expr
-    // `this.isRealNode(this._root) ? ... : undefined` can take the false branch.
-    (this as any)._root = this.NIL;
-  }
-}
-
-describe('RedBlackTree remaining-branch coverage', () => {
-  it('covers hint cache-maintenance binary-expr false paths (no cache update)', () => {
-    // direct attach left: hint.left empty, but extremes exist elsewhere.
-    const t1 = new RedBlackTree<number, number>([], { isMapMode: false });
-    for (const k of [50, 1, 100, 60]) t1.set(k, k);
-    const h60 = t1.getNode(60)!;
-
-    // Force hint.left to be empty (but keep global min/max as real).
-    h60._left = t1.NIL as any;
-
-    const min1 = (t1 as any)._header._left.key;
-    const max1 = (t1 as any)._header._right.key;
-
-    t1.setWithHintNode(55, 55, h60);
-    expect((t1 as any)._header._left.key).toBe(min1);
-    expect((t1 as any)._header._right.key).toBe(max1);
-
-    // direct attach right: hint.right empty.
-    const t2 = new RedBlackTree<number, number>([], { isMapMode: false });
-    for (const k of [50, 1, 100, 40]) t2.set(k, k);
-    const h40 = t2.getNode(40)!;
-
-    h40._right = t2.NIL as any;
-
-    const min2 = (t2 as any)._header._left.key;
-    const max2 = (t2 as any)._header._right.key;
-
-    t2.setWithHintNode(45, 45, h40);
-    expect((t2 as any)._header._left.key).toBe(min2);
-    expect((t2 as any)._header._right.key).toBe(max2);
-
-    // pred.right attach: force hint.left to be a predecessor whose right slot is empty.
-    const t3 = new RedBlackTree<number, number>([], { isMapMode: false });
-    for (const k of [50, 1, 100, 60]) t3.set(k, k);
-    const h60b = t3.getNode(60)!;
-    const pred40 = t3.getNode(50)!; // reuse an existing real node as predecessor anchor
-
-    pred40.parent = h60b as any;
-    pred40._right = t3.NIL as any;
-    h60b._left = pred40 as any;
-
-    const min3 = (t3 as any)._header._left.key;
-    const max3 = (t3 as any)._header._right.key;
-
-    t3.setWithHintNode(55, 55, h60b);
-    expect((t3 as any)._header._left.key).toBe(min3);
-    expect((t3 as any)._header._right.key).toBe(max3);
-
-    // succ.left attach: force hint.right to be a successor whose left slot is empty.
-    const t4 = new RedBlackTree<number, number>([], { isMapMode: false });
-    for (const k of [50, 1, 100, 40]) t4.set(k, k);
-    const h40b = t4.getNode(40)!;
-    const succ60 = t4.getNode(50)!; // reuse an existing real node as successor anchor
-
-    succ60.parent = h40b as any;
-    succ60._left = t4.NIL as any;
-    h40b._right = succ60 as any;
-
-    const min4 = (t4 as any)._header._left.key;
-    const max4 = (t4 as any)._header._right.key;
-
-    t4.setWithHintNode(45, 45, h40b);
-    expect((t4 as any)._header._left.key).toBe(min4);
-    expect((t4 as any)._header._right.key).toBe(max4);
-  });
-
-  it('covers _setKVNode boundary max update mapMode branches (defined + undefined)', () => {
-    const t = new RedBlackTree<number, string>(); // mapMode default
-    t.set(10, 'mid');
-    t.set(5, 'min');
-    t.set(15, 'max');
-
-    // defined: should store.set
-    t.set(15, 'max2');
-    expect(t.get(15)).toBe('max2');
-
-    // undefined overwrites value in node-index mapMode
-    t.set(15, undefined as any);
-    expect(t.get(15)).toBe(undefined);
-  });
-
-  it('covers delete(predicate) path and delete(node) ternary branch', () => {
-    const t = new RedBlackTree<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15]) t.set(k, k);
-
-    // delete(predicate)
-    const r1 = t.delete((node) => node?.key === 5);
-    expect(r1.length).toBe(1);
-    expect(t.has(5)).toBe(false);
-
-    // delete(node)
-    const n15 = t.getNode(15)!;
-    const r2 = t.delete(n15);
-    expect(r2.length).toBe(1);
-    expect(t.has(15)).toBe(false);
-  });
-
-  it('covers delete cache fallback cond-expr false branch when _root is corrupted to NIL', () => {
-    const t = new RBTTransplantCorruptRoot([], { isMapMode: false });
-    for (const k of [10, 5, 15, 1, 20]) t.set(k, k);
-
-    // Force fallback recompute block by corrupting min/max nodes.
-    (t as any)._minNode = undefined;
-    (t as any)._maxNode = undefined;
-
-    // Delete a node so size remains >0.
-    t.delete(1);
-
-    // Restore root so subsequent operations/tests aren't affected.
-    (t as any)._root = (t as any)._header.parent;
-  });
-});

package/test/unit/data-structures/binary-tree/red-black-tree.set-inputs.coverage.test.ts

@@ -1,64 +0,0 @@
-import { RedBlackTree, RedBlackTreeNode } from '../../../../src';
-
-class RBTWithBadInsert extends RedBlackTree<number, number> {
-  // Simulate an internal failure where _insert reports CREATED but does not establish a real root.
-  // This is purely to cover the defensive branch in set(node).
-  protected override _insert(__node: RedBlackTreeNode<number, number>): any {
-    // Ensure root stays NIL/undefined
-    (this as any)._setRoot(undefined);
-    return 'CREATED';
-  }
-}
-
-describe('RedBlackTree set() input/defensive branches coverage', () => {
-  it('returns false for nullish key inputs in key/entry paths', () => {
-    const t = new RedBlackTree<number, number>([], { isMapMode: false });
-
-    expect(t.set(null as any)).toBe(false);
-    expect(t.set(undefined as any)).toBe(false);
-
-    // entry with null/undefined key
-    expect(t.set([null as any, 1] as any)).toBe(false);
-    expect(t.set([undefined as any, 1] as any)).toBe(false);
-  });
-
-  it('key-only path delegates to _setKV and supports mapMode fast path', () => {
-    const t = new RedBlackTree<number, number>(); // mapMode default
-
-    // insert
-    expect(t.set(1, 10)).toBe(true);
-    expect(t.get(1)).toBe(10);
-
-    // update should hit _setKV fast-path (store.has)
-    expect(t.set(1, 20)).toBe(true);
-    expect(t.get(1)).toBe(20);
-
-    // update for missing key must fall through to _setKVNode
-    expect(t.set(2, 200)).toBe(true);
-    expect(t.get(2)).toBe(200);
-  });
-
-  it('node insertion path: defensive branch returns false when root is not real after CREATED', () => {
-    const t = new RBTWithBadInsert([], { isMapMode: false });
-    const n = new RedBlackTreeNode<number, number>(1, 1, 'BLACK');
-
-    expect(t.set(n)).toBe(false);
-    expect(t.size).toBe(0);
-  });
-
-  it('node insertion path: UPDATED branch returns true and updates mapMode store via _setValue', () => {
-    const t = new RedBlackTree<number, number>();
-
-    // First insert via node
-    const n1 = new RedBlackTreeNode<number, number>(1, 0 as any, 'BLACK');
-    expect(t.set(n1, 10)).toBe(true);
-    expect(t.get(1)).toBe(10);
-
-    // Second node with same key should trigger UPDATED in _insert -> set() UPDATED branch.
-    const n1b = new RedBlackTreeNode<number, number>(1, 0 as any, 'BLACK');
-    expect(t.set(n1b, 99)).toBe(true);
-
-    // mapMode uses _setValue, so value should reflect newValue.
-    expect(t.get(1)).toBe(99);
-  });
-});

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

@@ -1,79 +0,0 @@
-import { RedBlackTree, RedBlackTreeNode } from '../../../../src';
-
-class RBTBadKeyValue extends RedBlackTree<number, number> {
-  // Force set(node) to hit `if (!this.isRealNode(newNode)) return false;`
-  protected override _keyValueNodeOrEntryToNodeAndValue(
-    __keyNodeOrEntry: any,
-    _value?: any
-  ): [RedBlackTreeNode<number, number> | undefined, number | undefined] {
-    return [undefined, undefined];
-  }
-}
-
-describe('RedBlackTree _setKVNode parent==hMin/hMax cache maintenance coverage', () => {
-  it('post-insert cache maintenance: parent===hMax && lastCompared>0 updates max cache when header._right is corrupted to an interior node', () => {
-    const t = new RedBlackTree<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15, 1, 20]) t.set(k, k);
-
-    const n10 = t.getNode(10)!;
-
-    // Corrupt header max cache to an interior node that already has a right subtree,
-    // so boundary max attach fast-path is skipped.
-    (t as any)._header._right = n10;
-
-    // Insert a key that will attach as the right child of 10 in the normal path.
-    // (10.right exists (15), so it will descend; but 13 will attach as left of 15, not 10.
-    // So ensure 10.right is empty for parent===hMax; but that would re-enable boundary.
-    // Instead, force shape: make 10.right NIL temporarily (only for this coverage test).
-    n10._right = t.NIL as any;
-
-    // With corrupted hMax=10 and 10.right NIL, boundary block would try to attach as right of maxN;
-    // but boundary block only runs when cMin>0 with minN=header._left. Keep minN such that cMin<=0 by corrupting min to a larger key.
-    (t as any)._header._left = n10;
-
-    t.set(12, 12);
-
-    // Should have updated max cache to the newly inserted node via parent===hMax branch.
-    expect((t as any)._header._right.key).toBe(12);
-
-    // Repair caches (best-effort).
-    const root = (t as any)._header.parent;
-    (t as any)._root = root;
-    (t as any)._setMinCache(t.getLeftMost((x: any) => x, root));
-    (t as any)._setMaxCache(t.getRightMost((x: any) => x, root));
-  });
-
-  it('post-insert cache maintenance: parent===hMin && lastCompared<0 updates min cache when header._left is corrupted to an interior node', () => {
-    const t = new RedBlackTree<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15, 1, 20]) t.set(k, k);
-
-    const n10 = t.getNode(10)!;
-
-    // Corrupt header min cache to an interior node.
-    (t as any)._header._left = n10;
-    // Ensure boundary min attach is skipped: 10.left is real by default (5), so ok.
-
-    // Insert a key that will attach as the left child of 10 (normal path):
-    // force 10.left to be NIL temporarily to make parent===10.
-    n10._left = t.NIL as any;
-
-    // Also corrupt max so we don't enter max boundary block.
-    (t as any)._header._right = n10;
-
-    t.set(7, 7);
-
-    expect((t as any)._header._left.key).toBe(7);
-
-    // Repair caches.
-    const root = (t as any)._header.parent;
-    (t as any)._root = root;
-    (t as any)._setMinCache(t.getLeftMost((x: any) => x, root));
-    (t as any)._setMaxCache(t.getRightMost((x: any) => x, root));
-  });
-
-  it('set(node) early-return branch: _keyValueNodeOrEntryToNodeAndValue returns undefined node', () => {
-    const t = new RBTBadKeyValue([], { isMapMode: false });
-    const n = new RedBlackTreeNode<number, number>(1, 1, 'BLACK');
-    expect(t.set(n, 1)).toBe(false);
-  });
-});

package/test/unit/data-structures/binary-tree/red-black-tree.setkvnode-remaining.coverage.test.ts

@@ -1,44 +0,0 @@
-import { RedBlackTree } from '../../../../src';
-
-describe('RedBlackTree _setKVNode remaining branch coverage', () => {
-  it('normal search loop takes `current.right ?? NIL` with a real right child (covers binary-expr branch)', () => {
-    const t = new RedBlackTree<number, number>([], { isMapMode: false });
-    // Build a tree where root has a real right child.
-    t.set(10, 10);
-    t.set(15, 15);
-    t.set(20, 20);
-
-    // Skip boundary fast paths so we go through the normal search loop.
-    (t as any)._header._left = undefined;
-
-    // Insert a key greater than root so traversal takes the right-child branch with a real node.
-    expect(t.set(25, 25)).toBe(true);
-    expect(t.has(25)).toBe(true);
-  });
-
-  it('normal update path (mapMode) hits `_setValue` when nextValue is undefined (covers if/else at update)', () => {
-    const t = new RedBlackTree<number, string>(); // mapMode default
-    t.set(10, 'a');
-    t.set(5, 'b');
-    t.set(15, 'c');
-
-    // Ensure we do NOT take boundary min/max update fast paths.
-    (t as any)._header._left = undefined;
-    (t as any)._header._right = undefined;
-
-    // Update an existing key with undefined overwrites value in node-index mapMode.
-    t.set(10, undefined as any);
-    expect(t.get(10)).toBe(undefined);
-  });
-
-  it('boundary max-key update (mapMode) hits `_setValue` branch when nextValue is undefined', () => {
-    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 undefined overwrites value in node-index mapMode.
-    t.set(15, undefined as any);
-    expect(t.get(15)).toBe(undefined);
-  });
-});

package/test/unit/data-structures/binary-tree/red-black-tree.setkvnode-uncovered.coverage.test.ts

@@ -1,74 +0,0 @@
-import { RedBlackTree } from '../../../../src';
-
-class RBTBadFixup extends RedBlackTree<number, number> {
-  // Simulate an unexpected internal failure so `_setKVNode` hits the defensive `else return undefined`.
-  protected override _insertFixup(__node: any): void {
-    // Blow away root after "fixup".
-    (this as any)._setRoot(undefined);
-  }
-}
-
-describe('RedBlackTree _setKVNode uncovered-branch coverage', () => {
-  it('covers normal-path current=header.parent ?? NIL when header.parent is undefined (starts at NIL)', () => {
-    const t = new RedBlackTree<number, number>([], { isMapMode: false });
-
-    // Force normal path (minN becomes NIL via ??) and start walk from NIL.
-    (t as any)._header._left = undefined;
-    (t as any)._header.parent = undefined;
-
-    expect(t.set(1, 1)).toBe(true);
-    expect(t.getNode(1)?.key).toBe(1);
-  });
-
-  it('covers normal-path `current.left ?? NIL` / `current.right ?? NIL` in the search loop', () => {
-    const t = new RedBlackTree<number, number>([], { isMapMode: false });
-    t.set(10, 10);
-
-    // Skip boundary fast paths so we go through the normal search loop.
-    (t as any)._header._left = undefined;
-
-    // Force missing children so `?? NIL` branches are taken.
-    const root = (t as any)._header.parent;
-    root._left = undefined;
-    root._right = undefined;
-
-    expect(t.set(5, 5)).toBe(true);
-    expect(t.set(15, 15)).toBe(true);
-
-    expect(t.has(5)).toBe(true);
-    expect(t.has(15)).toBe(true);
-  });
-
-  it('covers boundary max-path reading `header._right ?? NIL` when header._right is undefined (safe comparator)', () => {
-    // Comparator that tolerates undefined keys from NIL.
-    const comparator = (a: number, b: any) => {
-      if (b === undefined || b === null) return -1; // ensures cMax < 0 so we do not attach/update under NIL
-      return a - b;
-    };
-
-    const t = new RedBlackTree<number, number>([], { isMapMode: false, comparator });
-    t.set(10, 10);
-    t.set(5, 5); // establish min
-
-    // Corrupt max cache only; boundary block should read `header._right ?? NIL`.
-    (t as any)._header._right = undefined;
-
-    // Key > min so we enter the max boundary block, but safe comparator prevents NIL-attach.
-    expect(t.set(8, 8)).toBe(true);
-    expect(t.has(8)).toBe(true);
-
-    // Repair max cache so we don't leak corruption.
-    const root = (t as any)._root;
-    (t as any)._setMaxCache(t.isRealNode(root) ? t.getRightMost((n: any) => n, root) : undefined);
-  });
-
-  it('covers defensive `return undefined` after fixup when root is not real (set returns false)', () => {
-    const t = new RBTBadFixup([], { isMapMode: false });
-
-    // Force normal path (avoid boundary attach) so we reach the fixup block.
-    (t as any)._header._left = undefined;
-
-    expect(t.set(1, 1)).toBe(false);
-    expect(t.size).toBe(0);
-  });
-});