data-structure-typed 2.3.0 → 2.4.0

package/test/performance/runner-config.json

@@ -1,39 +1,51 @@
 {
   "label": "default-plan",
   "include": [
-    "binary-tree/avl-tree.test.ts",
-    "binary-tree/binary-tree.test.ts",
-    "binary-tree/bst.test.ts",
-    "binary-tree/red-black-tree.test.ts",
-    "graph/directed-graph.test.ts",
-    "hash/hash-map.test.ts",
-    "heap/heap.test.ts",
-    "queue/queue.test.ts",
-    "queue/deque.test.ts",
+    "binary-tree/avl-tree.test.mjs",
+    "binary-tree/binary-tree.test.mjs",
+    "binary-tree/bst.test.mjs",
+    "binary-tree/red-black-tree.test.mjs",
+    "binary-tree/tree-set.test.mjs",
+    "binary-tree/tree-map.test.mjs",
+    "binary-tree/tree-multi-set.test.mjs",
+    "binary-tree/tree-multi-map.test.mjs",
+    "binary-tree/**/*.test.cpp",
+    "graph/**",
+    "hash/**",
+    "queue/queue.test.mjs",
+    "queue/deque.test.mjs",
+    "linked-list/**",
     "stack/**",
+    "priority-queue/**",
     "trie/**"
   ],
   "exclude": [
-    "**/experimental/**"
+    "**/experimental/**",
+    "heap/**",
+    "**/max-priority-queue*"
   ],
   "order": [
-    "red-black-tree",
-    "queue",
-    "deque",
-    "heap",
-    "avl-tree",
     "doubly-linked-list",
     "singly-linked-list",
     "linked-hash-map",
     "hash-map",
-    "map-graph",
-    "graph",
-    "directed-graph",
-    "undirected-graph",
+    "queue",
+    "deque",
     "priority-queue",
-    "binary-tree-overall",
+    "stack",
+    "red-black-tree",
+    "avl-tree",
+    "tree-set",
+    "tree-map",
+    "tree-multi-set",
+    "tree-multi-map",
     "bst",
+    "binary-tree",
+    "binary-tree-overall",
     "trie",
-    "stack"
+    "graph",
+    "directed-graph",
+    "undirected-graph",
+    "map-graph"
   ]
 }

package/test/unit/data-structures/base/iterable-element-base.more-branches.coverage.test.ts

@@ -12,19 +12,19 @@ class NumIter extends IterableElementBase<number, number> {
     throw new Error('Method not implemented.');
   }
   override map<EM, RM>(
-    callback: ElementCallback<number, number, EM>,
-    options?: IterableElementBaseOptions<EM, RM> | undefined,
-    thisArg?: unknown
+    _callback: ElementCallback<number, number, EM>,
+    _options?: IterableElementBaseOptions<EM, RM> | undefined,
+    _thisArg?: unknown
   ): IterableElementBase<EM, RM> {
     throw new Error('Method not implemented.');
   }
-  override mapSame(callback: ElementCallback<number, number, number>, thisArg?: unknown): this {
+  override mapSame(_callback: ElementCallback<number, number, number>, _thisArg?: unknown): this {
     throw new Error('Method not implemented.');
   }
-  override filter(predicate: ElementCallback<number, number, boolean>, thisArg?: unknown): this {
+  override filter(_predicate: ElementCallback<number, number, boolean>, _thisArg?: unknown): this {
     throw new Error('Method not implemented.');
   }
-  protected override _getIterator(...args: unknown[]): IterableIterator<number> {
+  protected override _getIterator(..._args: unknown[]): IterableIterator<number> {
     throw new Error('Method not implemented.');
   }
   constructor(private readonly data: number[]) {

package/test/unit/data-structures/base/linear-base.array.coverage.test.ts

@@ -7,16 +7,16 @@ class TestArrayLinear extends LinearBase<number, number> {
     throw new Error('Method not implemented.');
   }
   override map<EM, RM>(
-    callback: ElementCallback<number, number, EM>,
-    options?: IterableElementBaseOptions<EM, RM> | undefined,
-    thisArg?: unknown
+    _callback: ElementCallback<number, number, EM>,
+    _options?: IterableElementBaseOptions<EM, RM> | undefined,
+    _thisArg?: unknown
   ): IterableElementBase<EM, RM> {
     throw new Error('Method not implemented.');
   }
-  override mapSame(callback: ElementCallback<number, number, number>, thisArg?: unknown): this {
+  override mapSame(_callback: ElementCallback<number, number, number>, _thisArg?: unknown): this {
     throw new Error('Method not implemented.');
   }
-  override filter(predicate: ElementCallback<number, number, boolean>, thisArg?: unknown): this {
+  override filter(_predicate: ElementCallback<number, number, boolean>, _thisArg?: unknown): this {
     throw new Error('Method not implemented.');
   }
   private _arr: number[];

package/test/unit/data-structures/base/linear-base.concat-else.coverage.test.ts

@@ -4,22 +4,22 @@ import { LinearBase, LinkedListNode } from '../../../../src/data-structures/base
 type R = number;
 
 class ArrayLinear extends LinearBase<number, R> {
-  override setAt(index: number, value: number): boolean {
+  override setAt(_index: number, _value: number): boolean {
     throw new Error('Method not implemented.');
   }
   override reverse(): this {
     throw new Error('Method not implemented.');
   }
-  override delete(elementOrNode: number | LinkedListNode<number> | undefined): boolean {
+  override delete(_elementOrNode: number | LinkedListNode<number> | undefined): boolean {
     throw new Error('Method not implemented.');
   }
-  override deleteAt(pos: number): number | undefined {
+  override deleteAt(_pos: number): number | undefined {
     throw new Error('Method not implemented.');
   }
-  override addAt(index: number, newElementOrNode: number | LinkedListNode<number>): boolean {
+  override addAt(_index: number, _newElementOrNode: number | LinkedListNode<number>): boolean {
     throw new Error('Method not implemented.');
   }
-  protected override _getReverseIterator(...args: any[]): IterableIterator<number> {
+  protected override _getReverseIterator(..._args: any[]): IterableIterator<number> {
     throw new Error('Method not implemented.');
   }
   override isEmpty(): boolean {
@@ -29,16 +29,16 @@ class ArrayLinear extends LinearBase<number, R> {
     throw new Error('Method not implemented.');
   }
   override map<EM, RM>(
-    callback: ElementCallback<number, number, EM>,
-    options?: IterableElementBaseOptions<EM, RM> | undefined,
-    thisArg?: unknown
+    _callback: ElementCallback<number, number, EM>,
+    _options?: IterableElementBaseOptions<EM, RM> | undefined,
+    _thisArg?: unknown
   ): IterableElementBase<EM, RM> {
     throw new Error('Method not implemented.');
   }
-  override mapSame(callback: ElementCallback<number, number, number>, thisArg?: unknown): this {
+  override mapSame(_callback: ElementCallback<number, number, number>, _thisArg?: unknown): this {
     throw new Error('Method not implemented.');
   }
-  override filter(predicate: ElementCallback<number, number, boolean>, thisArg?: unknown): this {
+  override filter(_predicate: ElementCallback<number, number, boolean>, _thisArg?: unknown): this {
     throw new Error('Method not implemented.');
   }
   protected _data: number[];

package/test/unit/data-structures/base/linear-base.more-branches.coverage.test.ts

@@ -1,9 +1,6 @@
-import { LinearBase, LinearLinkedBase, LinkedListNode,  } from '../../../../src/data-structures/base/linear-base';
+import { LinearBase, LinearLinkedBase, LinkedListNode } from '../../../../src/data-structures/base/linear-base';
 import {
-  DoublyLinkedListNode,
-  DoublyLinkedListOptions,
   ElementCallback,
-  IterableElementBase,
   IterableElementBaseOptions
 } from '../../../../src';
 
@@ -87,19 +84,19 @@ class ArrayLinear extends LinearBase<number, any> {
     return false;
   }
 
-  filter(predicate: ElementCallback<number, any, boolean>, thisArg?: any): this {
+  filter(_predicate: ElementCallback<number, any, boolean>, _thisArg?: any): this {
     const out = this._createInstance();
 
     return out;
   }
 
   // @ts-ignore
-  map(callback: ElementCallback<number, any, number>, options: IterableElementBaseOptions<number, any> | undefined, thisArg: unknown | undefined): ArrayLinear {
+  map(_callback: ElementCallback<number, any, number>, options: IterableElementBaseOptions<number, any> | undefined, _thisArg: unknown | undefined): ArrayLinear {
     const out = this._createLike([], { ...(options ?? {}) });
     return out;
   }
 
-  mapSame(callback: ElementCallback<number, any, number>, thisArg: unknown | undefined): this {
+  mapSame(_callback: ElementCallback<number, any, number>, _thisArg: unknown | undefined): this {
     const out = this._createInstance();
 
     return out;
@@ -349,19 +346,19 @@ class NodeLinear extends LinearLinkedBase<number, any, LinkedListNode<number>> {
 
 
 
-  filter(predicate: ElementCallback<number, any, boolean>, thisArg?: any): this {
+  filter(_predicate: ElementCallback<number, any, boolean>, _thisArg?: any): this {
     const out = this._createInstance();
 
     return out;
   }
 
   // @ts-ignore
-  map(callback: ElementCallback<number, any, number>, options: IterableElementBaseOptions<number, any> | undefined, thisArg: unknown | undefined): ArrayLinear {
+  map(callback: ElementCallback<number, any, number>, options: IterableElementBaseOptions<number, any> | undefined, _thisArg: unknown | undefined): ArrayLinear {
     const out = this._createLike([], { ...(options ?? {}) });
     return out;
   }
 
-  mapSame(callback: ElementCallback<number, any, number>, thisArg: unknown | undefined): this {
+  mapSame(_callback: ElementCallback<number, any, number>, _thisArg: unknown | undefined): this {
     const out = this._createInstance();
 
     return out;

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

@@ -32,7 +32,7 @@ describe('AVL Tree Test', () => {
     expect(lesserSum).toBe(45);
 
     // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
-    expect(node15?.value).toBe(undefined);
+    expect(node15?.value).toBe(15);
     const dfs = avlTree.dfs(node => node, 'IN');
     expect(dfs[0].key).toBe(1);
     expect(dfs[dfs.length - 1].key).toBe(16);
@@ -118,11 +118,11 @@ describe('AVL Tree Test', () => {
     expect(avlTree.get(1)).toBe('b');
     const treeMap = new AVLTree<number>([4, 5, [1, '1'], 2, 3]);
     expect(treeMap.get(1)).toBe('1');
-    expect(treeMap.getNode(1)?.value).toBe(undefined);
+    expect(treeMap.getNode(1)?.value).toBe('1');
     treeMap.set(1, 'a');
     expect(treeMap.get(1)).toBe('a');
     treeMap.set([1, 'b']);
-    expect(treeMap.getNode(1)?.value).toBe(undefined);
+    expect(treeMap.getNode(1)?.value).toBe('b');
     expect(treeMap.get(1)).toBe('b');
   });
 });
@@ -158,7 +158,7 @@ describe('AVL Tree Test recursively', () => {
     expect(lesserSum).toBe(45);
 
     // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
-    expect(node15?.value).toBe(undefined);
+    expect(node15?.value).toBe(15);
 
     const dfs = avlTree.dfs(node => node, 'IN');
     expect(dfs[0].key).toBe(1);
@@ -437,7 +437,7 @@ describe('AVLTree iterative methods test', () => {
   it('should clone work well', () => {
     const cloned = avlTree.clone();
     expect(cloned.root?.left?.key).toBe(1);
-    expect(cloned.root?.right?.value).toBe(undefined);
+    expect(cloned.root?.right?.value).toBe('c');
   });
 
   it('should keys', () => {

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

@@ -120,10 +120,13 @@ describe('BinaryTree remaining branch coverage', () => {
     right.parent = root;
     (t as any)._setRoot(root);
 
-    // Ensure store has values.
-    (t as any)._store.set(1, 1000);
-    (t as any)._store.set(2, 2000);
-    (t as any)._store.set(3, 3000);
+    // Ensure store has node references (node-index store).
+    left.value = 1000;
+    root.value = 2000;
+    right.value = 3000;
+    (t as any)._store.set(1, left);
+    (t as any)._store.set(2, root);
+    (t as any)._store.set(3, right);
 
     // Force recursive iterator branch.
     (t as any).iterationType = 'RECURSIVE';

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

@@ -750,11 +750,11 @@ describe('BinaryTree', () => {
     expect(binTree.get(1)).toBe('b');
     const treeMap = new BinaryTree<number>([4, 5, [1, '1'], 2, 3]);
     expect(treeMap.get(1)).toBe('1');
-    expect(treeMap.getNode(1)?.value).toBe(undefined);
+    expect(treeMap.getNode(1)?.value).toBe('1');
     treeMap.set(1, 'a');
     expect(treeMap.get(1)).toBe('a');
     treeMap.set([1, 'b']);
-    expect(treeMap.getNode(1)?.value).toBe(undefined);
+    expect(treeMap.getNode(1)?.value).toBe('b');
     expect(treeMap.get(1)).toBe('b');
   });
 });
@@ -1034,7 +1034,7 @@ describe('BinaryTree', () => {
     const nodeB = binTree.getNode(3);
 
     expect(nodeA?.key).toBe(5);
-    expect(nodeA?.value).toBe(undefined);
+    expect(nodeA?.value).toBe('A');
     expect(nodeB?.key).toBe(3);
     expect(binTree.get(nodeB)).toBe('B');
   });
@@ -1359,7 +1359,7 @@ describe('BinaryTree (map mode) - higher-order & iteration', () => {
   it('clone(): preserves structure and allows get() by node', () => {
     const cloned = binaryTree.clone();
     expect(cloned.root?.left?.key).toBe(2);
-    expect(cloned.root?.right?.value).toBe(undefined);
+    expect(cloned.root?.right?.value).toBe('c');
     expect(cloned.get(cloned.root?.right)).toBe('c');
   });
 
@@ -1514,7 +1514,7 @@ describe('Coverage boosters - merge/print/iterator/startNode/addMany-mismatch/de
     expect(uOnly.startsWith('U for undefined')).toBe(true);
   });
 
-  it('clone in Map mode shares storage: updates in original visible in clone', () => {
+  it('clone in Map mode does not share storage: updates in original not visible in clone', () => {
     const t = new BinaryTree<number, string>(
       [
         [1, 'a'],
@@ -1525,8 +1525,8 @@ describe('Coverage boosters - merge/print/iterator/startNode/addMany-mismatch/de
     const c = t.clone() as BinaryTree<number, string>;
     // In the original tree, "replace" the value for the same key (Map mode triggers _store.set)
     t.set([2, 'B']);
-    // Because clone shares Map storage, the clone can also read the new value
-    expect(c.get(2)).toBe('B');
+    // Clone is independent; it keeps its own values
+    expect(c.get(2)).toBe('b');
   });
 });
 

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

@@ -22,7 +22,7 @@ describe('BST remaining reachable branch coverage (batch 3)', () => {
 
     const origIsPred = (t as any)._isPredicate;
     let calls = 0;
-    (t as any)._isPredicate = (x: any) => {
+    (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.

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

@@ -4,7 +4,7 @@ import { withMutedConsole } from '../../../utils/patch';
 
 const isDebug = isDebugTest;
 
-function expectSingleDeleteResult<K, V>(removed: any, expectedKey: K) {
+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();
@@ -450,11 +450,11 @@ describe('BST operations test', () => {
     expect(tree.get(1)).toBe('b');
     const treeMap = new BST<number>([4, 5, [1, '1'], 2, 3]);
     expect(treeMap.get(1)).toBe('1');
-    expect(treeMap.getNode(1)?.value).toBe(undefined);
+    expect(treeMap.getNode(1)?.value).toBe('1');
     treeMap.set(1, 'a');
     expect(treeMap.get(1)).toBe('a');
     treeMap.set([1, 'b']);
-    expect(treeMap.getNode(1)?.value).toBe(undefined);
+    expect(treeMap.getNode(1)?.value).toBe('b');
     expect(treeMap.get(1)).toBe('b');
   });
 
@@ -1128,7 +1128,7 @@ describe('BST iterative methods test', () => {
   it('should clone work well', () => {
     const cloned = bst.clone();
     expect(cloned.root?.left).toBe(undefined);
-    expect(cloned.root?.right?.value).toBe(undefined);
+    expect(cloned.root?.right?.value).toBe('b');
   });
 
   it('should keys', () => {

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

@@ -140,49 +140,36 @@ describe('Overall BinaryTree Test', () => {
     expect(clonedAVL.bfs()).toEqual([3, 5, 1, 9, 4, 2, 6]);
   });
 
+  // TreeMultiMap uses composition, not inheritance - tests use public API only
   it('Should clone a TreeMultiMap works fine', () => {
-    const tmm = new TreeMultiMap<number>([3, 6, 7, 1, 9], {
-      iterationType: 'RECURSIVE'
-    });
+    const tmm = new TreeMultiMap<number, string>();
+    tmm.set(3, 'a');
+    tmm.set(6, 'b');
+    tmm.set(7, 'c');
+    tmm.set(1, 'd');
+    tmm.set(9, 'e');
     expect(tmm.size).toBe(5);
-    tmm.set(2);
-    tmm.set(2);
-    tmm.set(2);
-    tmm.set(5);
-    tmm.set(4);
-    expect(tmm.root?.key).toBe(3);
-    expect(tmm.root?.left?.key).toBe(1);
-    expect(tmm.root?.left?.left?.key).toBe(NaN);
-    expect(tmm.root?.right?.key).toBe(7);
-    expect(tmm.root?.right?.left?.key).toBe(5);
-    expect(tmm.getNode(7)?.left?.key).toBe(5);
-    expect(tmm.getHeight()).toBe(3);
+    tmm.set(2, 'f');
+    tmm.set(2, 'g'); // duplicate key, adds to bucket
+    tmm.set(2, 'h'); // duplicate key, adds to bucket
+    tmm.set(5, 'i');
+    tmm.set(4, 'j');
+    expect(tmm.size).toBe(8); // 8 unique keys
+    expect(tmm.count(2)).toBe(3); // 3 values for key 2
     expect(tmm.has(9)).toBe(true);
     expect(tmm.has(7)).toBe(true);
-    expect(tmm.delete(7)[0].deleted?.key).toBe(7);
+    expect(tmm.delete(7)).toBe(true);
     expect(tmm.has(7)).toBe(false);
     expect(tmm.size).toBe(7);
-    expect(tmm.root?.key).toBe(3);
-    expect(tmm.root?.left?.key).toBe(1);
-    expect(tmm.root?.right?.key).toBe(9);
-    expect(tmm.root?.right?.left?.key).toBe(5);
-    expect(tmm.getNode(6)?.left?.key).toBe(NaN);
-    expect(tmm.getHeight()).toBe(3);
     expect(tmm.has(9)).toBe(true);
     expect(tmm.has(7)).toBe(false);
-    expect(tmm.bfs()).toEqual([3, 1, 9, 2, 5, 4, 6]);
-    // expect(tmm.bfs()).toEqual([6, 1, 9, 3, 2, 5, 4]);
+    
     const clonedTMM = tmm.clone();
     expect(clonedTMM.size).toBe(7);
-    expect(clonedTMM.root?.key).toBe(3);
-    expect(clonedTMM.root?.left?.key).toBe(1);
-    expect(clonedTMM.root?.right?.key).toBe(5);
-    expect(clonedTMM.root?.right?.left?.key).toBe(4);
-    expect(clonedTMM.getNode(6)?.left?.key).toBe(NaN);
-    expect(clonedTMM.getHeight()).toBe(3);
     expect(clonedTMM.has(9)).toBe(true);
     expect(clonedTMM.has(7)).toBe(false);
-    expect(clonedTMM.bfs()).toEqual([3, 1, 5, 2, 4, 9, 6]);
+    expect(clonedTMM.count(2)).toBe(3);
+    expect(clonedTMM.get(2)).toEqual(['f', 'g', 'h']);
   });
 
   it('Should clone a RedBlackTree works fine', () => {

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

@@ -13,6 +13,6 @@ describe('RedBlackTree boundary max update coverage', () => {
 
     expect(t.get(15)).toBe('max2');
     // Assert store updated (fast-path uses store.set).
-    expect((t as any)._store.get(15)).toBe('max2');
+    expect((t as any)._store.get(15)?.value).toBe('max2');
   });
 });

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

@@ -33,7 +33,7 @@ describe('RedBlackTree stale cache insert coverage', () => {
     // 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');
+    // node-index mapMode: undefined overwrites.
+    expect(t.get(1)).toBe(undefined);
   });
 });

package/test/unit/data-structures/binary-tree/red-black-tree.hint-mapmode-defined.coverage.test.ts

@@ -8,11 +8,11 @@ describe('RedBlackTree setWithHintNode mapMode defined-value branches', () => {
 
     const n5 = t.setWithHintNode(5, 5, h10);
     expect(n5?.key).toBe(5);
-    expect((t as any)._store.get(5)).toBe(5);
+    expect((t as any)._store.get(5)?.value).toBe(5);
 
     const n15 = t.setWithHintNode(15, 15, h10);
     expect(n15?.key).toBe(15);
-    expect((t as any)._store.get(15)).toBe(15);
+    expect((t as any)._store.get(15)?.value).toBe(15);
   });
 
   it('pred.right and succ.left attach with defined values uses store.set branches', () => {
@@ -24,12 +24,12 @@ describe('RedBlackTree setWithHintNode mapMode defined-value branches', () => {
     t.setWithHintNode(5, 5, h10);
     const n7 = t.setWithHintNode(7, 7, h10);
     expect(n7?.key).toBe(7);
-    expect((t as any)._store.get(7)).toBe(7);
+    expect((t as any)._store.get(7)?.value).toBe(7);
 
     // Ensure right is real so we take succ path.
     t.setWithHintNode(15, 15, h10);
     const n12 = t.setWithHintNode(12, 12, h10);
     expect(n12?.key).toBe(12);
-    expect((t as any)._store.get(12)).toBe(12);
+    expect((t as any)._store.get(12)?.value).toBe(12);
   });
 });

package/test/unit/data-structures/binary-tree/red-black-tree.hint-mapmode-undefined.coverage.test.ts

@@ -1,7 +1,7 @@
 import { RedBlackTree } from '../../../../src';
 
 describe('RedBlackTree setWithHintNode mapMode undefined-value branches', () => {
-  it('direct attach left/right with undefined value hits _setValue branches (no store entry)', () => {
+  it('direct attach left/right with undefined value stores nodes (node-index store)', () => {
     const t = new RedBlackTree<number, number>(); // mapMode default
     t.set(10, 10);
     const h10 = t.getNode(10)!;
@@ -9,12 +9,12 @@ describe('RedBlackTree setWithHintNode mapMode undefined-value branches', () =>
     const n5 = t.setWithHintNode(5, undefined as any, h10);
     expect(n5?.key).toBe(5);
     expect(t.getNode(5)).toBeTruthy();
-    expect((t as any)._store.has(5)).toBe(false);
+    expect((t as any)._store.has(5)).toBe(true);
 
     const n15 = t.setWithHintNode(15, undefined as any, h10);
     expect(n15?.key).toBe(15);
     expect(t.getNode(15)).toBeTruthy();
-    expect((t as any)._store.has(15)).toBe(false);
+    expect((t as any)._store.has(15)).toBe(true);
   });
 
   it('pred.right and succ.left attach with undefined value hit _setValue branches', () => {
@@ -29,7 +29,7 @@ describe('RedBlackTree setWithHintNode mapMode undefined-value branches', () =>
     const n7 = t.setWithHintNode(7, undefined as any, h10);
     expect(n7?.key).toBe(7);
     expect(t.getNode(7)).toBeTruthy();
-    expect((t as any)._store.has(7)).toBe(false);
+    expect((t as any)._store.has(7)).toBe(true);
 
     // Ensure right is real so we take the succ path.
     t.setWithHintNode(15, 15, h10);
@@ -38,6 +38,6 @@ describe('RedBlackTree setWithHintNode mapMode undefined-value branches', () =>
     const n12 = t.setWithHintNode(12, undefined as any, h10);
     expect(n12?.key).toBe(12);
     expect(t.getNode(12)).toBeTruthy();
-    expect((t as any)._store.has(12)).toBe(false);
+    expect((t as any)._store.has(12)).toBe(true);
   });
 });

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

@@ -1,4 +1,4 @@
-import { RedBlackTree, RedBlackTreeNode } from '../../../../src';
+import { RedBlackTree } from '../../../../src';
 
 class RBTWithBadCreate extends RedBlackTree<number, number> {
   override createNode(key: number, value?: number): any {
@@ -25,9 +25,9 @@ describe('RedBlackTree setWithHintNode more branch coverage', () => {
     m.setWithHintNode(10, 3, mh10);
     expect(m.get(10)).toBe(3);
 
-    // undefined update should preserve existing value (existing semantics).
+    // undefined update overwrites value in node-index mapMode.
     m.setWithHintNode(10, undefined as any, mh10);
-    expect(m.get(10)).toBe(3);
+    expect(m.get(10)).toBe(undefined);
   });
 
   it('covers c0<0: direct attach to hint.left, pred fallback, and pred.right attach', () => {

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

@@ -85,9 +85,9 @@ describe('RedBlackTree remaining-branch coverage', () => {
     t.set(15, 'max2');
     expect(t.get(15)).toBe('max2');
 
-    // undefined: should go through _setValue branch, preserving existing value
+    // undefined overwrites value in node-index mapMode
     t.set(15, undefined as any);
-    expect(t.get(15)).toBe('max2');
+    expect(t.get(15)).toBe(undefined);
   });
 
   it('covers delete(predicate) path and delete(node) ternary branch', () => {

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

@@ -3,7 +3,7 @@ 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 {
+  protected override _insert(__node: RedBlackTreeNode<number, number>): any {
     // Ensure root stays NIL/undefined
     (this as any)._setRoot(undefined);
     return 'CREATED';

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

@@ -3,7 +3,7 @@ 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,
+    __keyNodeOrEntry: any,
     _value?: any
   ): [RedBlackTreeNode<number, number> | undefined, number | undefined] {
     return [undefined, undefined];

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

@@ -26,9 +26,9 @@ describe('RedBlackTree _setKVNode remaining branch coverage', () => {
     (t as any)._header._left = undefined;
     (t as any)._header._right = undefined;
 
-    // Update an existing key with undefined => mapMode uses _setValue branch and preserves existing value.
+    // Update an existing key with undefined overwrites value in node-index mapMode.
     t.set(10, undefined as any);
-    expect(t.get(10)).toBe('a');
+    expect(t.get(10)).toBe(undefined);
   });
 
   it('boundary max-key update (mapMode) hits `_setValue` branch when nextValue is undefined', () => {
@@ -37,8 +37,8 @@ describe('RedBlackTree _setKVNode remaining branch coverage', () => {
     t.set(5, 'min');
     t.set(15, 'max');
 
-    // Update existing max key with undefined should take boundary cMax===0 fast-path and go through _setValue.
+    // Update existing max key with undefined overwrites value in node-index mapMode.
     t.set(15, undefined as any);
-    expect(t.get(15)).toBe('max');
+    expect(t.get(15)).toBe(undefined);
   });
 });

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

@@ -2,7 +2,7 @@ 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 {
+  protected override _insertFixup(__node: any): void {
     // Blow away root after "fixup".
     (this as any)._setRoot(undefined);
   }

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

@@ -195,11 +195,11 @@ describe('RedBlackTree 1', () => {
     expect(rbTree.get(1)).toBe('b');
     const treeMap = new RedBlackTree<number>([4, 5, [1, '1'], 2, 3]);
     expect(treeMap.get(1)).toBe('1');
-    expect(treeMap.getNode(1)?.value).toBe(undefined);
+    expect(treeMap.getNode(1)?.value).toBe('1');
     treeMap.set(1, 'a');
     expect(treeMap.get(1)).toBe('a');
     treeMap.set([1, 'b']);
-    expect(treeMap.getNode(1)?.value).toBe(undefined);
+    expect(treeMap.getNode(1)?.value).toBe('b');
     expect(treeMap.get(1)).toBe('b');
   });
 });