data-structure-typed 2.2.7 → 2.3.0

package/test/unit/data-structures/binary-tree/bst.bound-by-predicate.coverage.test.ts

@@ -0,0 +1,33 @@
+import { BST } from '../../../../src';
+
+describe('BST _boundByPredicate coverage', () => {
+  it('recursive traversal: returns first in-order match and short-circuits once found', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15, 3, 7, 12, 18]) t.set(k, k);
+
+    const pred = (node: any) => node.key >= 7;
+    const out = (t as any)._boundByPredicate(pred, 'RECURSIVE');
+    expect(out?.key).toBe(7);
+  });
+
+  it('recursive traversal: returns undefined when no match', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15]) t.set(k, k);
+
+    const out = (t as any)._boundByPredicate((node: any) => node.key === 999, 'RECURSIVE');
+    expect(out).toBeUndefined();
+  });
+
+  it('iterative traversal: returns first match and breaks when stack pop is not real', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15]) t.set(k, k);
+
+    const out = (t as any)._boundByPredicate((node: any) => node.key === 10, 'ITERATIVE');
+    expect(out?.key).toBe(10);
+
+    // Force the internal stack-pop guard branch by clearing the tree and calling again.
+    t.clear();
+    const out2 = (t as any)._boundByPredicate((node: any) => node.key === 1, 'ITERATIVE');
+    expect(out2).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,94 @@
+import { BST, Range } from '../../../../src';
+
+/**
+ * Coverage-focused tests for overload dispatch + iterationType string handling.
+ *
+ * IMPORTANT: Do NOT touch the existing @example tests (used for docs generation).
+ */
+describe('BST coverage: overloads & bound helpers', () => {
+  let bst: BST<number, string>;
+
+  beforeEach(() => {
+    bst = new BST<number, string>([10, 5, 15, 3, 7, 12, 20, 1, 4, 6, 8, 11, 13, 18, 25]);
+  });
+
+  it('ceiling supports iterationType passed as 2nd arg string', () => {
+    expect(bst.ceiling(9, n => n.key, 'ITERATIVE')).toBe(10);
+    expect(bst.ceiling(10, n => n.key, 'RECURSIVE')).toBe(10);
+  });
+
+  it('ceiling supports callback + explicit iterationType', () => {
+    const got = bst.ceiling(14, node => node.key, 'ITERATIVE');
+    expect(got).toBe(15);
+  });
+
+  it('higher supports iterationType passed as 2nd arg string', () => {
+    expect(bst.higher(10, n => n.key , 'ITERATIVE')).toBe(11);
+    expect(bst.higher(25, n => n.key, 'RECURSIVE')).toBeUndefined();
+  });
+
+  it('higher supports callback + explicit iterationType', () => {
+    const got = bst.higher(14, node => node.key, 'RECURSIVE');
+    expect(got).toBe(15);
+  });
+
+  it('floor supports iterationType passed as 2nd arg string', () => {
+    expect(bst.floor(9, n => n.key, 'ITERATIVE')).toBe(8);
+    expect(bst.floor(1, n => n.key, 'RECURSIVE')).toBe(1);
+  });
+
+  it('floor supports callback + explicit iterationType', () => {
+    const got = bst.floor(14, node => node.key, 'ITERATIVE');
+    expect(got).toBe(13);
+  });
+
+  it('lower supports iterationType passed as 2nd arg string', () => {
+    expect(bst.lower(10, n => n.key, 'ITERATIVE')).toBe(8);
+    expect(bst.lower(1, n => n.key, 'RECURSIVE')).toBeUndefined();
+  });
+
+  it('lower supports callback + explicit iterationType', () => {
+    const got = bst.lower(11, node => node.key, 'RECURSIVE');
+    expect(got).toBe(10);
+  });
+
+  it('bound helpers accept a NodePredicate input (smoke)', () => {
+    // These overloads allow a predicate; this primarily exercises the dispatch logic.
+    const pred = (node: any) => node.key === 12;
+    expect(bst.ceiling(pred, node => node.key)).toBe(12);
+
+    // Predicate overload semantics are implementation-defined; we mainly want to exercise the dispatch.
+    const higher = bst.higher(pred, node => node.key);
+    expect(higher).toBeDefined();
+    expect(higher as number).toBeGreaterThanOrEqual(12);
+
+    expect(bst.floor(pred, node => node.key)).toBe(12);
+
+    const lower = bst.lower(pred, node => node.key);
+    expect(lower === 11 || lower === 12).toBe(true);
+  });
+
+  it('getNode covers predicate branch + runtime Range branch + entry edge cases', () => {
+    // predicate branch (delegates to getNodes)
+    const pred = (node: any) => node.key === 12;
+    expect(bst.getNode(pred)?.key).toBe(12);
+
+    // runtime Range branch (Range is not in overload but allowed at runtime)
+    const range = new Range(6, 12);
+    const inRange = bst.getNode(range as any);
+    expect(inRange?.key).toBe(6);
+
+    // entry branch: null/undefined key should return undefined
+    expect(bst.getNode([null as any, 'x'] as any)).toBeUndefined();
+    expect(bst.getNode([undefined as any, 'x'] as any)).toBeUndefined();
+  });
+
+  it('search covers entry-with-null-key early return and Range search callback path', () => {
+    // entry with null key => should yield [] (targetKey stays undefined)
+    expect(bst.search([null as any, 'x'] as any)).toEqual([]);
+
+    // Range search should exercise isRange predicate path + callback
+    const out = bst.search(new Range(6, 12), false, node => node.key, undefined, 'ITERATIVE');
+    expect(out).toEqual([6, 7, 8, 10, 11, 12]);
+  });
+});

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

@@ -0,0 +1,70 @@
+import { BST } from '../../../../src';
+
+describe('BST _deleteByKey coverage', () => {
+  it('returns false when key not found', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15]) t.set(k, k);
+
+    expect((t as any)._deleteByKey(999)).toBe(false);
+    expect(t.size).toBe(3);
+  });
+
+  it('deletes node with no left child (node.left === undefined)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 15]) t.set(k, k);
+
+    expect((t as any)._deleteByKey(10)).toBe(true);
+    expect(t.has(10)).toBe(false);
+    expect(t.has(15)).toBe(true);
+  });
+
+  it('deletes node with no right child (node.right === undefined)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5]) t.set(k, k);
+
+    expect((t as any)._deleteByKey(10)).toBe(true);
+    expect(t.has(10)).toBe(false);
+    expect(t.has(5)).toBe(true);
+  });
+
+  it('deletes node with two children where successor is direct right child (succ.parent === node)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    //      10
+    //     /  \
+    //    5   15
+    for (const k of [10, 5, 15]) t.set(k, k);
+
+    expect((t as any)._deleteByKey(10)).toBe(true);
+    expect(t.has(10)).toBe(false);
+    expect(t.has(5)).toBe(true);
+    expect(t.has(15)).toBe(true);
+
+    // Root should now be 15.
+    expect((t as any)._root?.key).toBe(15);
+    expect((t as any)._root?.left?.key).toBe(5);
+  });
+
+  it('deletes node with two children where successor is deeper (succ.parent !== node) and minNode loop handles null left', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    //        10
+    //       /  \
+    //      5    20
+    //          /  \
+    //         15  25
+    //        /
+    //       13   (successor)
+    for (const k of [10, 5, 20, 15, 25, 13]) t.set(k, k);
+
+    // Make successor.left explicitly null to cover `x.left !== null` check in minNode loop.
+    const n13 = t.getNode(13)!;
+    n13._left = null as any;
+
+    expect((t as any)._deleteByKey(10)).toBe(true);
+    expect(t.has(10)).toBe(false);
+
+    // New root should be successor (13).
+    expect((t as any)._root?.key).toBe(13);
+    expect(t.has(20)).toBe(true);
+    expect(t.getNode(20)?.parent?.key).toBe(13);
+  });
+});

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

@@ -0,0 +1,37 @@
+import { BST, Range } from '../../../../src';
+
+describe('BST deleteWhere coverage', () => {
+  it('deleteWhere(predicate) uses default args (onlyOne/startNode/iterationType)', () => {
+    const bst = new BST<number, number>();
+    for (const k of [4, 2, 6, 1, 3, 5, 7]) bst.set(k, k);
+
+    // delete evens (should remove 2,4,6)
+    const res = bst.deleteWhere(node => node.key % 2 === 0);
+    expect(res.length).toBe(3);
+    expect(bst.has(2)).toBe(false);
+    expect(bst.has(4)).toBe(false);
+    expect(bst.has(6)).toBe(false);
+
+    // odd keys remain
+    expect([...bst].map(([k]) => k).sort((a, b) => a - b)).toEqual([1, 3, 5, 7]);
+  });
+
+  it('deleteWhere(range, onlyOne=true) deletes a single match', () => {
+    const bst = new BST<number, number>();
+    for (const k of [10, 5, 15, 3, 7, 12, 18]) bst.set(k, k);
+
+    const r = new Range<number>(7, 15, true, true);
+    const before = bst.size;
+
+    const res = bst.deleteWhere(r, true);
+    expect(res.length).toBe(1);
+    expect(bst.size).toBe(before - 1);
+  });
+
+  it('protected _createLike default iterable branch', () => {
+    const bst = new BST<number, number>([2, 1, 3]);
+    const like = (bst as any)._createLike();
+    expect(like).toBeInstanceOf(BST);
+    expect(like.size).toBe(0);
+  });
+});

package/test/unit/data-structures/binary-tree/bst.floor-lower-predicate.coverage.test.ts

@@ -0,0 +1,29 @@
+import { BST } from '../../../../src';
+
+describe('BST floor()/lower() predicate + callback-shape coverage', () => {
+  it('floor(predicate, iterationTypeString) returns node.key (actualCallback undefined branch)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15, 3, 7]) t.set(k, k);
+
+    // callback is a string => treated as iterationType; actualCallback stays undefined.
+    const out = t.floor((node: any) => node.key <= 7, 'ITERATIVE' as any);
+    // floor-by-predicate returns the last node satisfying the predicate.
+    expect(out).toBe(7);
+  });
+
+  it('lower(predicate, iterationTypeString) returns node.key (actualCallback undefined branch)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15, 3, 7]) t.set(k, k);
+
+    const out = t.lower((node: any) => node.key < 7, 'RECURSIVE' as any);
+    // lower-by-predicate returns the last node satisfying the predicate.
+    expect(out).toBe(5);
+  });
+
+  it('_floorByPredicate hits early return when root is not real (covers dfs guard)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    // empty tree
+    const out = (t as any)._floorByPredicate((n: any) => !!n, 'RECURSIVE');
+    expect(out).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,72 @@
+import { BST } from '../../../../src';
+
+describe('BST floor() and setMany() extra coverage', () => {
+  it('floor: nullish input returns undefined (callback string and callback function cases)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+
+    expect(t.floor(null as any, 'RECURSIVE' as any)).toBeUndefined();
+    expect(t.floor(undefined as any, 'ITERATIVE' as any)).toBeUndefined();
+
+    // also with callback function
+    expect(t.floor(null as any, (n: any) => n.key)).toBeUndefined();
+  });
+
+  it('floor: entry with null/undefined key returns undefined (covers key-null guard)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15]) t.set(k, k);
+
+    expect(t.floor([null as any, 1] as any, (n: any) => n.key)).toBeUndefined();
+    expect(t.floor([undefined as any, 1] as any, (n: any) => n.key)).toBeUndefined();
+  });
+
+  it('floor: predicate path returns callback(node) when found and undefined when not found', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15, 3, 7]) t.set(k, k);
+
+    const found = t.floor((node: any) => node.key >= 7, (node: any) => node.key, 'ITERATIVE' as any);
+    // floor-by-predicate returns the first node that satisfies the predicate in the chosen traversal.
+    expect(found).toBe(15);
+
+    const notFound = t.floor((node: any) => node.key === 999, (node: any) => node.key, 'RECURSIVE' as any);
+    expect(notFound).toBeUndefined();
+  });
+
+  it('setMany: non-balanced insertion converts raw items via _toEntryFn and passes values iterator', () => {
+    type Raw = { k: number | null; v: number };
+    const t = new BST<number, number, Raw>([], { isMapMode: false } as any);
+
+    // Enable raw conversion.
+    (t as any)._toEntryFn = (r: Raw) => [r.k as any, r.v];
+
+    const raws: Raw[] = [
+      { k: 3, v: 30 },
+      { k: 1, v: 10 },
+      { k: null, v: 999 } // should become a [null, v] entry; set should fail
+    ];
+
+    const out = t.setMany(raws as any, [undefined, undefined, undefined], false);
+    expect(out.length).toBe(3);
+
+    expect(t.has(1)).toBe(true);
+    expect(t.has(3)).toBe(true);
+  });
+
+  it('setMany: balanced insertion sort comparator covers (keyA==null || keyB==null) fallback', () => {
+    type Raw = { k: number | null; v: number };
+    const t = new BST<number, number, Raw>([], { isMapMode: false } as any);
+    (t as any)._toEntryFn = (r: Raw) => [r.k as any, r.v];
+
+    // Use only raw objects (arrays are also typeof 'object' and would be treated as raw when _toEntryFn is set).
+    // Include a null key so the sort comparator hits the `return 0` fallback.
+    const items: Raw[] = [
+      { k: null, v: 0 },
+      { k: 2, v: 20 },
+      { k: 1, v: 10 }
+    ];
+    const out = t.setMany(items as any, undefined, true, 'ITERATIVE' as any);
+    expect(out.length).toBe(3);
+
+    expect(t.has(1)).toBe(true);
+    expect(t.has(2)).toBe(true);
+  });
+});

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

@@ -0,0 +1,22 @@
+import { BST } from '../../../../src';
+import { Range } from '../../../../src/common';
+
+describe('BST getNode() extra coverage', () => {
+  it('treats runtime Range input by forwarding to getNodes and returning first result', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15, 3, 7, 12, 18]) t.set(k, k);
+
+    const range = new Range(6, 13, true, true);
+    const n = t.getNode(range as any);
+    expect(n?.key).toBe(7);
+  });
+
+  it('returns undefined when ensureNode(startNode) fails (startNode is null)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15]) t.set(k, k);
+
+    // bypass type and pass null startNode
+    const out = t.getNode(10 as any, null as any);
+    expect(out).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,100 @@
+import { BST } from '../../../../src';
+import { Range } from '../../../../src/common';
+
+describe('BST remaining misc branch coverage', () => {
+  it('getNode(range) returns undefined when getNodes(range) is empty (covers ?? fallback)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15]) t.set(k, k);
+
+    const range = new Range(100, 200);
+    const out = t.getNode(range as any);
+    expect(out).toBeUndefined();
+  });
+
+  it('search(entry) with undefined key covers the second operand of (k !== null && k !== undefined)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15]) t.set(k, k);
+
+    const out = t.search([undefined as any, 1] as any);
+    expect(out).toEqual([]);
+  });
+
+  it('floor(entry null key, callback as string) hits the typeof-callback guard branch', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15]) t.set(k, k);
+
+    expect(t.floor([null as any, 1] as any, 'RECURSIVE' as any)).toBeUndefined();
+  });
+
+  it('lower(predicate, callback fn) returns undefined when predicate matches none (covers cond-expr false branch)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15]) t.set(k, k);
+
+    const out = t.lower((n: any) => n.key === 999, (n: any) => n.key, 'ITERATIVE' as any);
+    expect(out).toBeUndefined();
+  });
+
+  it('lower(key, callback fn) returns undefined when no lower key exists (covers key-path cond-expr false branch)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15]) t.set(k, k);
+
+    const out = t.lower(1 as any, (n: any) => n.key, 'ITERATIVE' as any);
+    expect(out).toBeUndefined();
+  });
+
+  it('default comparator throws when comparing object keys (covers typeof b === object arm)', () => {
+    const t = new BST<any, any>([], { isMapMode: false } as any);
+    const cmp = (t as any)._createDefaultComparator();
+    expect(() => cmp(1, {})).toThrow(TypeError);
+  });
+
+  it('_floorByPredicate(RECURSIVE) updates result when predicate becomes true (covers predicate(cur) true branch)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15, 3, 7]) t.set(k, k);
+
+    const node = (t as any)._floorByPredicate((n: any) => n.key <= 7, 'RECURSIVE');
+    expect(node?.key).toBe(7);
+  });
+
+  it('_lowerByPredicate(RECURSIVE) early-returns on empty tree (covers !isRealNode(cur) guard)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    const node = (t as any)._lowerByPredicate((n: any) => !!n, 'RECURSIVE');
+    expect(node).toBeUndefined();
+  });
+
+  it('_bound(entry null key) returns undefined (covers key-null guard in _bound)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15]) t.set(k, k);
+
+    const out = (t as any)._bound([null as any, 1] as any, true, 'ITERATIVE');
+    expect(out).toBeUndefined();
+  });
+
+  it('_boundByPredicate(RECURSIVE) early-returns on empty tree (covers !isRealNode(cur) guard)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    const out = (t as any)._boundByPredicate((n: any) => !!n, 'RECURSIVE');
+    expect(out).toBeUndefined();
+  });
+
+  it('_deleteByKey takes the cmp>0 left-walk branch and transplant(p.left===u) branch', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    // Ensure root has a left child so delete walks left and transplant sees p.left===u.
+    for (const k of [10, 5, 15]) t.set(k, k);
+
+    expect((t as any)._deleteByKey(1)).toBe(false); // walk left, not found
+    expect((t as any)._deleteByKey(5)).toBe(true); // delete left child
+    expect(t.has(5)).toBe(false);
+  });
+
+  it('setMany balanced sort comparator hits isRealNode(b) branch when inputs include nodes', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [2, 1, 3]) t.set(k, k);
+
+    const n1 = t.getNode(1)!;
+    const n2 = t.getNode(2)!;
+    const n3 = t.getNode(3)!;
+
+    const out = t.setMany([n3, n1, n2] as any, undefined, true, 'ITERATIVE' as any);
+    expect(out.length).toBe(3);
+  });
+});

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

@@ -0,0 +1,133 @@
+import { BST, BSTNode } from '../../../../src';
+
+describe('BST additional branch coverage (batch 2)', () => {
+  it('search(): forces pruning key-branches by toggling _isPredicate (covers shouldVisitLeft/Right key-path guards)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    t.set(10, 10);
+
+    // Make the first _isPredicate check return true (to skip the key fast-path),
+    // but subsequent calls return false (so pruning takes the key-search branches).
+    const origIsPredicate = (t as any)._isPredicate;
+    let first = true;
+    (t as any)._isPredicate = () => {
+      if (first) {
+        first = false;
+        return true;
+      }
+      return false;
+    };
+    try {
+      // Root has no real children => shouldVisitLeft/Right hits `!isRealNode(cur.left/right)` early returns.
+      expect(t.search(7 as any, false, n => n.key)).toEqual([]);
+
+      // Add children and try again so the compare-based pruning expressions execute too.
+      t.set(5, 5);
+      t.set(15, 15);
+
+      expect(t.search(7 as any, false, n => n.key)).toEqual([]);
+      expect(t.search(12 as any, false, n => n.key)).toEqual([]);
+    } finally {
+      (t as any)._isPredicate = origIsPredicate;
+    }
+  });
+
+  it('setMany(): covers raw-key path in both recursive and iterative builders, and hits !popped continue via pop monkeypatch', () => {
+    type Raw = { k: number; v: string };
+    const t = new BST<number, string, Raw>([], {
+      isMapMode: false,
+      toEntryFn: (r: Raw) => [r.k, r.v]
+    });
+
+    const raws: Raw[] = [
+      { k: 3, v: 'c' },
+      { k: 1, v: 'a' },
+      { k: 2, v: 'b' }
+    ];
+
+    // Recursive path hits `if (this.isRaw(key)) ... this.set(entry)`.
+    const insertedR = t.setMany(raws as any, undefined as any, false, 'RECURSIVE');
+    expect(insertedR.length).toBe(3);
+    expect(t.get(1)).toBe('a');
+
+    // Iterative path: monkeypatch pop once to return undefined so `if (!popped) continue` executes.
+    const origPop = Array.prototype.pop;
+    let did = false;
+    try {
+      // reset tree
+      t.clear();
+      Array.prototype.pop = function () {
+        if (!did) {
+          did = true;
+          return undefined as any;
+        }
+        return origPop.call(this);
+      };
+
+      const insertedI = t.setMany(raws as any, undefined as any, false, 'ITERATIVE');
+      expect(insertedI.length).toBe(3);
+      expect(t.get(2)).toBe('b');
+    } finally {
+      Array.prototype.pop = origPop;
+    }
+  });
+
+  it('floor/lower: covers nullish key entry guards and callback-string/empty branches', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    t.setMany([1, 2, 3] as any);
+
+    // entry with nullish key => should return undefined through guard branches
+    expect(t.floor([undefined, 1] as any)).toBeUndefined();
+    expect(t.lower([undefined, 1] as any)).toBeUndefined();
+
+    // null input with callback string => also returns undefined (guard branch)
+    expect(t.lower(undefined as any, 'RECURSIVE' as any)).toBeUndefined();
+  });
+
+  it('_floorByPredicate/_lowerByPredicate/_boundByPredicate iterative: hits break when stack.pop returns non-real (Array.pop monkeypatch)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    t.set(2, 2);
+    t.set(1, 1);
+    t.set(3, 3);
+
+    const origPop = Array.prototype.pop;
+    let did = false;
+    try {
+      Array.prototype.pop = function () {
+        if (!did) {
+          did = true;
+          return undefined as any;
+        }
+        return origPop.call(this);
+      };
+
+      // Access protected helpers via any and force ITERATIVE.
+      // With pop monkeypatch, these may return undefined due to early-break; we only care about executing the branch.
+      expect(() => (t as any)._floorByPredicate((n: BSTNode<number, number>) => n.key <= 2, 'ITERATIVE')).not.toThrow();
+      did = false;
+      expect(() => (t as any)._lowerByPredicate((n: BSTNode<number, number>) => n.key < 2, 'ITERATIVE')).not.toThrow();
+      did = false;
+      expect(() => (t as any)._boundByPredicate((n: BSTNode<number, number>) => n.key >= 2, true, 'ITERATIVE')).not.toThrow();
+    } finally {
+      Array.prototype.pop = origPop;
+    }
+  });
+
+  it('_deleteByKey: covers transplant else-branch (u is right child) and minNode(!x) early return via null corruption', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    // Build: 2 with children 1 and 3
+    t.set(2, 2);
+    t.set(1, 1);
+    t.set(3, 3);
+
+    // delete right child => transplant sees p.left!==u and takes p.right=v branch
+    expect((t as any)._deleteByKey(3)).toBe(true);
+    expect(t.get(3)).toBeUndefined();
+
+    // Corrupt: make node.right null so two-children branch is taken but minNode receives null
+    // and hits `if (!x) return undefined;`.
+    const n2 = t.getNode(2)!;
+    (n2 as any).right = null;
+
+    expect(() => (t as any)._deleteByKey(2)).toThrow();
+  });
+});

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

@@ -0,0 +1,45 @@
+import { BST } from '../../../../src';
+
+describe('BST remaining reachable branch coverage (batch 3)', () => {
+  it('search(): entry with nullish key does not set targetKey (covers entry[0] nullish guard)', () => {
+    const t = new BST<number, number>();
+    t.set(1, 1);
+
+    // Should not throw; should return empty due to targetKey undefined.
+    const res = (t as any).search([null, 1], (n: any) => n.key);
+    expect(res).toEqual([]);
+  });
+
+  it('search(): forces key-pruning branches to evaluate inside shouldVisitLeft/Right by toggling _isPredicate', () => {
+    const t = new BST<number, number>();
+    t.setMany([
+      [2, 2],
+      [1, 1],
+      [3, 3]
+    ]);
+
+    const pred = (node: any) => node.key === 2;
+
+    const origIsPred = (t as any)._isPredicate;
+    let calls = 0;
+    (t as any)._isPredicate = (x: any) => {
+      calls++;
+      // search() calls _isPredicate multiple times (isPred calc + ensurePredicate + pruning closures).
+      // Keep it true for the initial plumbing, then flip to false so pruning takes the key-pruning branch.
+      if (calls <= 3) return true;
+      return false;
+    };
+
+    try {
+      const out = (t as any).search(pred, (n: any) => n.key);
+      expect(out).toEqual([2]);
+    } finally {
+      (t as any)._isPredicate = origIsPred;
+    }
+  });
+
+  it('lower(): nullish input + nullish callback hits `|| !callback` branch', () => {
+    const t = new BST<number, number>();
+    expect((t as any).lower(undefined, undefined)).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,36 @@
+import { BST } from '../../../../src';
+
+describe('BST remaining reachable branch coverage (batch 4)', () => {
+  it('search(): entry with defined key sets targetKey (covers entry[0] non-nullish branch)', () => {
+    const t = new BST<number, number>();
+    t.setMany([
+      [1, 1],
+      [2, 2],
+      [3, 3]
+    ]);
+
+    const res = (t as any).search([2, undefined], (n: any) => n.key);
+    expect(res).toEqual([2]);
+  });
+
+  it('setMany(): recursive balanced build hits isRaw(key) branch', () => {
+    type Raw = { k: number; v: number };
+    const t = new BST<number, number, Raw>([], {
+      toEntryFn: (r: Raw) => [r.k, r.v]
+    });
+
+    const inserted = t.setMany(
+      [
+        { k: 2, v: 20 },
+        { k: 1, v: 10 },
+        { k: 3, v: 30 }
+      ],
+      undefined,
+      true,
+      'RECURSIVE'
+    );
+
+    expect(inserted).toHaveLength(3);
+    expect(t.get(2)).toBe(20);
+  });
+});