@futdevpro/nts-dynamo 1.15.102 → 1.15.104

package/src/_modules/local-vector-search/_services/lvs-vector-pool.control-service.spec.ts

@@ -1,507 +1,507 @@
-import { LVS_Search_Mode } from '../_enums/lvs-search-mode.enum';
-import { LVS_SearchResult } from '../_models/lvs-search-result.interface';
-import { LVS_VectorPool_ControlService } from './lvs-vector-pool.control-service';
-
-describe('| LVS_VectorPool_ControlService', () => {
-  let vectorPool: LVS_VectorPool_ControlService;
-
-  beforeEach(() => {
-    vectorPool = new LVS_VectorPool_ControlService();
-  });
-
-  describe('| Constructor/Initialization', () => {
-    it('| should initialize with empty pools', () => {
-      const all: Map<string, number[]> = vectorPool.getAll();
-      expect(all.size).toBe(0);
-    });
-  });
-
-  describe('| addVector', () => {
-    it('| should add a valid vector to the pool', () => {
-      const id: string = 'vector1';
-      const vector: number[] = [1, 2, 3];
-
-      vectorPool.addVector(id, vector);
-
-      const all: Map<string, number[]> = vectorPool.getAll();
-      expect(all.size).toBe(1);
-      expect(all.has(id)).toBeTrue();
-      expect(all.get(id)).toEqual(vector);
-    });
-
-    it('| should add multiple vectors to the pool', () => {
-      vectorPool.addVector('vector1', [1, 2, 3]);
-      vectorPool.addVector('vector2', [4, 5, 6]);
-      vectorPool.addVector('vector3', [7, 8, 9]);
-
-      const all: Map<string, number[]> = vectorPool.getAll();
-      expect(all.size).toBe(3);
-    });
-
-    it('| should throw error when ID is empty string', () => {
-      expect(() => {
-        vectorPool.addVector('', [1, 2, 3]);
-      }).toThrowError('Vector ID is required');
-    });
-
-    it('| should throw error when vector is empty array', () => {
-      expect(() => {
-        vectorPool.addVector('vector1', []);
-      }).toThrowError('Vector must be a non-empty array');
-    });
-
-    it('| should throw error when vector is not an array', () => {
-      expect(() => {
-        vectorPool.addVector('vector1', null as any);
-      }).toThrowError('Vector must be a non-empty array');
-    });
-
-    it('| should throw error when vector contains non-finite number', () => {
-      expect(() => {
-        vectorPool.addVector('vector1', [1, 2, Infinity]);
-      }).toThrowError('Vector must contain only finite numbers at index 2');
-    });
-
-    it('| should throw error when vector contains NaN', () => {
-      expect(() => {
-        vectorPool.addVector('vector1', [1, 2, NaN]);
-      }).toThrowError('Vector must contain only finite numbers at index 2');
-    });
-
-    it('| should store normalized vector internally', () => {
-      const id: string = 'vector1';
-      const vector: number[] = [3, 4]; // Magnitude = 5, normalized = [0.6, 0.8]
-
-      vectorPool.addVector(id, vector);
-
-      // Verify original vector is stored
-      const all: Map<string, number[]> = vectorPool.getAll();
-      expect(all.get(id)).toEqual(vector);
-    });
-  });
-
-  describe('| removeVector', () => {
-    it('| should remove an existing vector from the pool', () => {
-      vectorPool.addVector('vector1', [1, 2, 3]);
-      vectorPool.addVector('vector2', [4, 5, 6]);
-
-      vectorPool.removeVector('vector1');
-
-      const all: Map<string, number[]> = vectorPool.getAll();
-      expect(all.size).toBe(1);
-      expect(all.has('vector1')).toBeFalse();
-      expect(all.has('vector2')).toBeTrue();
-    });
-
-    it('| should not throw when removing non-existent vector', () => {
-      expect(() => {
-        vectorPool.removeVector('non-existent');
-      }).not.toThrow();
-    });
-
-    it('| should remove vector from both pools', () => {
-      vectorPool.addVector('vector1', [1, 2, 3]);
-      vectorPool.removeVector('vector1');
-
-      const all: Map<string, number[]> = vectorPool.getAll();
-      expect(all.size).toBe(0);
-    });
-  });
-
-  describe('| updateVector', () => {
-    it('| should update an existing vector', () => {
-      vectorPool.addVector('vector1', [1, 2, 3]);
-      const newVector: number[] = [4, 5, 6];
-
-      vectorPool.updateVector('vector1', newVector);
-
-      const all: Map<string, number[]> = vectorPool.getAll();
-      expect(all.get('vector1')).toEqual(newVector);
-    });
-
-    it('| should throw error when updating non-existent vector', () => {
-      expect(() => {
-        vectorPool.updateVector('non-existent', [1, 2, 3]);
-      }).toThrowError('Vector with ID "non-existent" does not exist');
-    });
-  });
-
-  describe('| clearPool', () => {
-    it('| should clear a populated pool', () => {
-      vectorPool.addVector('vector1', [1, 2, 3]);
-      vectorPool.addVector('vector2', [4, 5, 6]);
-      vectorPool.addVector('vector3', [7, 8, 9]);
-
-      vectorPool.clearPool();
-
-      const all: Map<string, number[]> = vectorPool.getAll();
-      expect(all.size).toBe(0);
-    });
-
-    it('| should not throw when clearing empty pool', () => {
-      expect(() => {
-        vectorPool.clearPool();
-      }).not.toThrow();
-    });
-  });
-
-  describe('| getAll', () => {
-    it('| should return a copy of the pool, not a reference', () => {
-      vectorPool.addVector('vector1', [1, 2, 3]);
-      const all1: Map<string, number[]> = vectorPool.getAll();
-      const all2: Map<string, number[]> = vectorPool.getAll();
-
-      expect(all1).not.toBe(all2);
-      expect(all1.size).toBe(all2.size);
-    });
-
-    it('| should return empty map when pool is empty', () => {
-      const all: Map<string, number[]> = vectorPool.getAll();
-      expect(all.size).toBe(0);
-    });
-  });
-
-  describe('| cosineSimilarity (static)', () => {
-    it('| should return 1 for identical vectors', () => {
-      const vector: number[] = [1, 2, 3];
-      const similarity: number = LVS_VectorPool_ControlService.cosineSimilarity(vector, vector);
-      expect(similarity).toBeCloseTo(1, 10);
-    });
-
-    it('| should return approximately 0 for orthogonal vectors', () => {
-      const vector1: number[] = [1, 0, 0];
-      const vector2: number[] = [0, 1, 0];
-      const similarity: number = 
-        LVS_VectorPool_ControlService.cosineSimilarity(vector1, vector2);
-      expect(similarity).toBeCloseTo(0, 10);
-    });
-
-    it('| should throw error for vectors with different dimensions', () => {
-      const vector1: number[] = [1, 2, 3];
-      const vector2: number[] = [1, 2];
-
-      expect(() => {
-        LVS_VectorPool_ControlService.cosineSimilarity(vector1, vector2);
-      }).toThrowError('Vectors must have the same dimension. Got 3 and 2');
-    });
-
-    it('| should calculate correct cosine similarity for known vectors', () => {
-      // Two vectors pointing in similar direction
-      const vector1: number[] = [1, 1, 0];
-      const vector2: number[] = [1, 0, 0];
-      // Normalized: [1/√2, 1/√2, 0] and [1, 0, 0]
-      // Dot product: 1/√2 ≈ 0.707
-      const similarity: number = 
-        LVS_VectorPool_ControlService.cosineSimilarity(vector1, vector2);
-      expect(similarity).toBeCloseTo(1 / Math.sqrt(2), 10);
-    });
-
-    it('| should handle zero vector', () => {
-      const vector1: number[] = [0, 0, 0];
-      const vector2: number[] = [1, 2, 3];
-      const similarity: number = 
-        LVS_VectorPool_ControlService.cosineSimilarity(vector1, vector2);
-      expect(similarity).toBeCloseTo(0, 10);
-    });
-  });
-
-  describe('| l2Distance (static)', () => {
-    it('| should return 0 for identical vectors', () => {
-      const vector: number[] = [1, 2, 3];
-      const distance: number = LVS_VectorPool_ControlService.l2Distance(vector, vector);
-      expect(distance).toBe(0);
-    });
-
-    it('| should throw error for vectors with different dimensions', () => {
-      const vector1: number[] = [1, 2, 3];
-      const vector2: number[] = [1, 2];
-
-      expect(() => {
-        LVS_VectorPool_ControlService.l2Distance(vector1, vector2);
-      }).toThrowError('Vectors must have the same dimension. Got 3 and 2');
-    });
-
-    it('| should calculate correct L2 distance for known vectors', () => {
-      const vector1: number[] = [0, 0, 0];
-      const vector2: number[] = [3, 4, 0];
-      // Distance = √(3² + 4² + 0²) = √25 = 5
-      const distance: number = LVS_VectorPool_ControlService.l2Distance(vector1, vector2);
-      expect(distance).toBe(5);
-    });
-
-    it('| should calculate correct L2 distance for 1D vectors', () => {
-      const vector1: number[] = [5];
-      const vector2: number[] = [2];
-      const distance: number = LVS_VectorPool_ControlService.l2Distance(vector1, vector2);
-      expect(distance).toBe(3);
-    });
-  });
-
-  describe('| search', () => {
-    beforeEach(() => {
-      // Add test vectors
-      vectorPool.addVector('vec1', [1, 0, 0]);
-      vectorPool.addVector('vec2', [0, 1, 0]);
-      vectorPool.addVector('vec3', [0, 0, 1]);
-      vectorPool.addVector('vec4', [1, 1, 0]);
-    });
-
-    it('| should return empty array for empty pool', () => {
-      const emptyPool: LVS_VectorPool_ControlService = new LVS_VectorPool_ControlService();
-      const results: LVS_SearchResult[] = emptyPool.search([1, 0, 0], 3, LVS_Search_Mode.cosineSimilarity);
-      expect(results.length).toBe(0);
-    });
-
-    it('| should return results in descending order for cosine similarity', () => {
-      const query: number[] = [1, 0, 0];
-      const results: LVS_SearchResult[] = vectorPool.search(
-        query, 
-        4, 
-        LVS_Search_Mode.cosineSimilarity
-      );
-
-      expect(results.length).toBe(4);
-      // vec1 should be most similar (identical)
-      expect(results[0].id).toBe('vec1');
-      expect(results[0].score).toBeCloseTo(1, 10);
-      // Results should be in descending order
-      for (let i: number = 0; i < results.length - 1; i++) {
-        expect(results[i].score).toBeGreaterThanOrEqual(results[i + 1].score);
-      }
-    });
-
-    it('| should return results in ascending order for L2 distance', () => {
-      const query: number[] = [1, 0, 0];
-      const results: LVS_SearchResult[] = vectorPool.search(
-        query, 
-        4, 
-        LVS_Search_Mode.l2Distance
-      );
-
-      expect(results.length).toBe(4);
-      // vec1 should be closest (distance = 0)
-      expect(results[0].id).toBe('vec1');
-      expect(results[0].score).toBe(0);
-      // Results should be in ascending order
-      for (let i: number = 0; i < results.length - 1; i++) {
-        expect(results[i].score).toBeLessThanOrEqual(results[i + 1].score);
-      }
-    });
-
-    it('| should limit results to top-K when k < pool size', () => {
-      const query: number[] = [1, 0, 0];
-      const results: LVS_SearchResult[] = vectorPool.search(
-        query, 
-        2, 
-        LVS_Search_Mode.cosineSimilarity
-      );
-
-      expect(results.length).toBe(2);
-    });
-
-    it('| should return all results when k > pool size', () => {
-      const query: number[] = [1, 0, 0];
-      const results: LVS_SearchResult[] = vectorPool.search(
-        query, 
-        10, 
-        LVS_Search_Mode.cosineSimilarity
-      );
-
-      expect(results.length).toBe(4);
-    });
-
-    it('| should return all results when k = pool size', () => {
-      const query: number[] = [1, 0, 0];
-      const results: LVS_SearchResult[] = vectorPool.search(
-        query, 
-        4, 
-        LVS_Search_Mode.cosineSimilarity
-      );
-
-      expect(results.length).toBe(4);
-    });
-
-    it('| should throw error for dimension mismatch', () => {
-      const query: number[] = [1, 0]; // 2D query, pool has 3D vectors
-
-      expect(() => {
-        vectorPool.search(query, 3, LVS_Search_Mode.cosineSimilarity);
-      }).toThrowError('Query vector dimension (2) does not match pool vector dimension (3)');
-    });
-
-    it('| should throw error for empty query vector', () => {
-      expect(() => {
-        vectorPool.search([], 3, LVS_Search_Mode.cosineSimilarity);
-      }).toThrowError('Query vector must be a non-empty array');
-    });
-
-    it('| should throw error for non-array query', () => {
-      expect(() => {
-        vectorPool.search(null as any, 3, LVS_Search_Mode.cosineSimilarity);
-      }).toThrowError('Query vector must be a non-empty array');
-    });
-
-    it('| should throw error for k = 0', () => {
-      expect(() => {
-        vectorPool.search([1, 0, 0], 0, LVS_Search_Mode.cosineSimilarity);
-      }).toThrowError('k must be a positive number');
-    });
-
-    it('| should throw error for negative k', () => {
-      expect(() => {
-        vectorPool.search([1, 0, 0], -1, LVS_Search_Mode.cosineSimilarity);
-      }).toThrowError('k must be a positive number');
-    });
-
-    it('| should throw error for unknown search mode', () => {
-      expect(() => {
-        vectorPool.search([1, 0, 0], 3, 'unknown-mode' as LVS_Search_Mode);
-      }).toThrowError('Unknown search mode: unknown-mode');
-    });
-
-    it('| should return correct scores for cosine similarity', () => {
-      const query: number[] = [1, 0, 0];
-      const results: LVS_SearchResult[] = vectorPool.search(
-        query, 
-        4, 
-        LVS_Search_Mode.cosineSimilarity
-      );
-
-      // vec1 should have score = 1 (identical)
-      const vec1Result: LVS_SearchResult | undefined =
-        results.find((r: LVS_SearchResult) => r.id === 'vec1');
-      expect(vec1Result).toBeDefined();
-      expect(vec1Result!.score).toBeCloseTo(1, 10);
-    });
-
-    it('| should produce cosine scores IDENTICAL to static cosineSimilarity (precomputed-normalized perf optimization, BFR-AM-013)', () => {
-      // Regression-guard: a search optimalizalt (precomputed-normalized + alloc-mentes) cosine-ja
-      // viselkedes-identikus a regi per-osszehasonlitas `cosineSimilarity(query, vector)`-ral.
-      const query: number[] = [0.3, 0.7, 0.2];
-      const results: LVS_SearchResult[] = vectorPool.search(query, 4, LVS_Search_Mode.cosineSimilarity);
-
-      expect(results.length).toBe(4);
-      const originals: Map<string, number[]> = vectorPool.getAll();
-      for (const result of results) {
-        const original: number[] | undefined = originals.get(result.id);
-        expect(original).toBeDefined();
-        const expected: number = LVS_VectorPool_ControlService.cosineSimilarity(query, original!);
-        expect(result.score).toBeCloseTo(expected, 10);
-      }
-    });
-
-    it('| should return correct scores for L2 distance', () => {
-      const query: number[] = [1, 0, 0];
-      const results: LVS_SearchResult[] = vectorPool.search(
-        query, 
-        4, 
-        LVS_Search_Mode.l2Distance
-      );
-
-      // vec1 should have score = 0 (identical)
-      const vec1Result: LVS_SearchResult | undefined =
-        results.find((r: LVS_SearchResult) => r.id === 'vec1');
-      expect(vec1Result).toBeDefined();
-      expect(vec1Result!.score).toBe(0);
-    });
-
-    it('| should restrict results to the candidateIds set (cosine)', () => {
-      const query: number[] = [1, 0, 0];
-      const candidateIds: Set<string> = new Set<string>(['vec2', 'vec3']);
-      const results: LVS_SearchResult[] = vectorPool.search(
-        query, 10, LVS_Search_Mode.cosineSimilarity, candidateIds
-      );
-      // CSAK a jelölt-halmaz ID-jai jelenhetnek meg (vec1/vec4 kizárva).
-      expect(results.length).toBe(2);
-      for (const r of results) {
-        expect(candidateIds.has(r.id)).toBe(true);
-      }
-    });
-
-    it('| should restrict results to the candidateIds set (L2)', () => {
-      const query: number[] = [1, 0, 0];
-      const candidateIds: Set<string> = new Set<string>(['vec1', 'vec4']);
-      const results: LVS_SearchResult[] = vectorPool.search(
-        query, 10, LVS_Search_Mode.l2Distance, candidateIds
-      );
-      expect(results.length).toBe(2);
-      expect(results.map((r: LVS_SearchResult) => r.id).sort()).toEqual(['vec1', 'vec4']);
-    });
-
-    it('| should give candidateId-scoped scores IDENTICAL to an unfiltered search filtered post-hoc', () => {
-      // A scoped keresés EREDMÉNYE (score-ok + sorrend) bit-azonos a teljes keresés azon
-      // részhalmazával, amit utólag a candidate-ID-kra szűrnénk — a szűrés csak SZŰKÍT, nem torzít.
-      const query: number[] = [1, 1, 0];
-      const candidateIds: Set<string> = new Set<string>(['vec1', 'vec2', 'vec4']);
-      const scoped: LVS_SearchResult[] = vectorPool.search(query, 10, LVS_Search_Mode.cosineSimilarity, candidateIds);
-      const full: LVS_SearchResult[] = vectorPool
-        .search(query, 10, LVS_Search_Mode.cosineSimilarity)
-        .filter((r: LVS_SearchResult) => candidateIds.has(r.id));
-      expect(scoped.length).toBe(full.length);
-      for (let i: number = 0; i < scoped.length; i++) {
-        expect(scoped[i].id).toBe(full[i].id);
-        expect(scoped[i].score).toBeCloseTo(full[i].score, 12);
-      }
-    });
-
-    it('| should return empty array for an empty candidateIds set', () => {
-      const results: LVS_SearchResult[] = vectorPool.search(
-        [1, 0, 0], 10, LVS_Search_Mode.cosineSimilarity, new Set<string>()
-      );
-      expect(results.length).toBe(0);
-    });
-  });
-
-  describe('| normalizedOnly mode (memory-optimized cosine-only pool)', () => {
-    let pool: LVS_VectorPool_ControlService;
-
-    beforeEach(() => {
-      pool = new LVS_VectorPool_ControlService({ normalizedOnly: true });
-      pool.addVector('vec1', [1, 0, 0]);
-      pool.addVector('vec2', [0, 1, 0]);
-      pool.addVector('vec3', [1, 1, 0]);
-    });
-
-    it('| should NOT store raw vectors (getAll empty) but size() correct', () => {
-      expect(pool.getAll().size).toBe(0);
-      expect(pool.size()).toBe(3);
-    });
-
-    it('| cosine search works identically to a normal pool', () => {
-      const normal: LVS_VectorPool_ControlService = new LVS_VectorPool_ControlService();
-      normal.addVector('vec1', [1, 0, 0]);
-      normal.addVector('vec2', [0, 1, 0]);
-      normal.addVector('vec3', [1, 1, 0]);
-
-      const query: number[] = [1, 0.2, 0];
-      const a: LVS_SearchResult[] = pool.search(query, 3, LVS_Search_Mode.cosineSimilarity);
-      const b: LVS_SearchResult[] = normal.search(query, 3, LVS_Search_Mode.cosineSimilarity);
-      expect(a.length).toBe(b.length);
-      for (let i: number = 0; i < a.length; i++) {
-        expect(a[i].id).toBe(b[i].id);
-        expect(a[i].score).toBeCloseTo(b[i].score, 12);
-      }
-    });
-
-    it('| cosine search honors candidateIds in normalizedOnly mode', () => {
-      const results: LVS_SearchResult[] = pool.search(
-        [1, 0, 0], 10, LVS_Search_Mode.cosineSimilarity, new Set<string>(['vec2', 'vec3'])
-      );
-      expect(results.length).toBe(2);
-      for (const r of results) {
-        expect(['vec2', 'vec3']).toContain(r.id);
-      }
-    });
-
-    it('| l2Distance throws in normalizedOnly mode (no raw vectors)', () => {
-      expect(() => pool.search([1, 0, 0], 3, LVS_Search_Mode.l2Distance))
-        .toThrowError(/normalizedOnly/);
-    });
-
-    it('| updateVector works (checks normalized pool, not raw)', () => {
-      expect(() => pool.updateVector('vec1', [0, 0, 1])).not.toThrow();
-      expect(() => pool.updateVector('missing', [0, 0, 1])).toThrowError(/does not exist/);
-    });
-  });
-});
-
+import { LVS_Search_Mode } from '../_enums/lvs-search-mode.enum';
+import { LVS_SearchResult } from '../_models/lvs-search-result.interface';
+import { LVS_VectorPool_ControlService } from './lvs-vector-pool.control-service';
+
+describe('| LVS_VectorPool_ControlService', () => {
+  let vectorPool: LVS_VectorPool_ControlService;
+
+  beforeEach(() => {
+    vectorPool = new LVS_VectorPool_ControlService();
+  });
+
+  describe('| Constructor/Initialization', () => {
+    it('| should initialize with empty pools', () => {
+      const all: Map<string, number[]> = vectorPool.getAll();
+      expect(all.size).toBe(0);
+    });
+  });
+
+  describe('| addVector', () => {
+    it('| should add a valid vector to the pool', () => {
+      const id: string = 'vector1';
+      const vector: number[] = [1, 2, 3];
+
+      vectorPool.addVector(id, vector);
+
+      const all: Map<string, number[]> = vectorPool.getAll();
+      expect(all.size).toBe(1);
+      expect(all.has(id)).toBeTrue();
+      expect(all.get(id)).toEqual(vector);
+    });
+
+    it('| should add multiple vectors to the pool', () => {
+      vectorPool.addVector('vector1', [1, 2, 3]);
+      vectorPool.addVector('vector2', [4, 5, 6]);
+      vectorPool.addVector('vector3', [7, 8, 9]);
+
+      const all: Map<string, number[]> = vectorPool.getAll();
+      expect(all.size).toBe(3);
+    });
+
+    it('| should throw error when ID is empty string', () => {
+      expect(() => {
+        vectorPool.addVector('', [1, 2, 3]);
+      }).toThrowError('Vector ID is required');
+    });
+
+    it('| should throw error when vector is empty array', () => {
+      expect(() => {
+        vectorPool.addVector('vector1', []);
+      }).toThrowError('Vector must be a non-empty array');
+    });
+
+    it('| should throw error when vector is not an array', () => {
+      expect(() => {
+        vectorPool.addVector('vector1', null as any);
+      }).toThrowError('Vector must be a non-empty array');
+    });
+
+    it('| should throw error when vector contains non-finite number', () => {
+      expect(() => {
+        vectorPool.addVector('vector1', [1, 2, Infinity]);
+      }).toThrowError('Vector must contain only finite numbers at index 2');
+    });
+
+    it('| should throw error when vector contains NaN', () => {
+      expect(() => {
+        vectorPool.addVector('vector1', [1, 2, NaN]);
+      }).toThrowError('Vector must contain only finite numbers at index 2');
+    });
+
+    it('| should store normalized vector internally', () => {
+      const id: string = 'vector1';
+      const vector: number[] = [3, 4]; // Magnitude = 5, normalized = [0.6, 0.8]
+
+      vectorPool.addVector(id, vector);
+
+      // Verify original vector is stored
+      const all: Map<string, number[]> = vectorPool.getAll();
+      expect(all.get(id)).toEqual(vector);
+    });
+  });
+
+  describe('| removeVector', () => {
+    it('| should remove an existing vector from the pool', () => {
+      vectorPool.addVector('vector1', [1, 2, 3]);
+      vectorPool.addVector('vector2', [4, 5, 6]);
+
+      vectorPool.removeVector('vector1');
+
+      const all: Map<string, number[]> = vectorPool.getAll();
+      expect(all.size).toBe(1);
+      expect(all.has('vector1')).toBeFalse();
+      expect(all.has('vector2')).toBeTrue();
+    });
+
+    it('| should not throw when removing non-existent vector', () => {
+      expect(() => {
+        vectorPool.removeVector('non-existent');
+      }).not.toThrow();
+    });
+
+    it('| should remove vector from both pools', () => {
+      vectorPool.addVector('vector1', [1, 2, 3]);
+      vectorPool.removeVector('vector1');
+
+      const all: Map<string, number[]> = vectorPool.getAll();
+      expect(all.size).toBe(0);
+    });
+  });
+
+  describe('| updateVector', () => {
+    it('| should update an existing vector', () => {
+      vectorPool.addVector('vector1', [1, 2, 3]);
+      const newVector: number[] = [4, 5, 6];
+
+      vectorPool.updateVector('vector1', newVector);
+
+      const all: Map<string, number[]> = vectorPool.getAll();
+      expect(all.get('vector1')).toEqual(newVector);
+    });
+
+    it('| should throw error when updating non-existent vector', () => {
+      expect(() => {
+        vectorPool.updateVector('non-existent', [1, 2, 3]);
+      }).toThrowError('Vector with ID "non-existent" does not exist');
+    });
+  });
+
+  describe('| clearPool', () => {
+    it('| should clear a populated pool', () => {
+      vectorPool.addVector('vector1', [1, 2, 3]);
+      vectorPool.addVector('vector2', [4, 5, 6]);
+      vectorPool.addVector('vector3', [7, 8, 9]);
+
+      vectorPool.clearPool();
+
+      const all: Map<string, number[]> = vectorPool.getAll();
+      expect(all.size).toBe(0);
+    });
+
+    it('| should not throw when clearing empty pool', () => {
+      expect(() => {
+        vectorPool.clearPool();
+      }).not.toThrow();
+    });
+  });
+
+  describe('| getAll', () => {
+    it('| should return a copy of the pool, not a reference', () => {
+      vectorPool.addVector('vector1', [1, 2, 3]);
+      const all1: Map<string, number[]> = vectorPool.getAll();
+      const all2: Map<string, number[]> = vectorPool.getAll();
+
+      expect(all1).not.toBe(all2);
+      expect(all1.size).toBe(all2.size);
+    });
+
+    it('| should return empty map when pool is empty', () => {
+      const all: Map<string, number[]> = vectorPool.getAll();
+      expect(all.size).toBe(0);
+    });
+  });
+
+  describe('| cosineSimilarity (static)', () => {
+    it('| should return 1 for identical vectors', () => {
+      const vector: number[] = [1, 2, 3];
+      const similarity: number = LVS_VectorPool_ControlService.cosineSimilarity(vector, vector);
+      expect(similarity).toBeCloseTo(1, 10);
+    });
+
+    it('| should return approximately 0 for orthogonal vectors', () => {
+      const vector1: number[] = [1, 0, 0];
+      const vector2: number[] = [0, 1, 0];
+      const similarity: number = 
+        LVS_VectorPool_ControlService.cosineSimilarity(vector1, vector2);
+      expect(similarity).toBeCloseTo(0, 10);
+    });
+
+    it('| should throw error for vectors with different dimensions', () => {
+      const vector1: number[] = [1, 2, 3];
+      const vector2: number[] = [1, 2];
+
+      expect(() => {
+        LVS_VectorPool_ControlService.cosineSimilarity(vector1, vector2);
+      }).toThrowError('Vectors must have the same dimension. Got 3 and 2');
+    });
+
+    it('| should calculate correct cosine similarity for known vectors', () => {
+      // Two vectors pointing in similar direction
+      const vector1: number[] = [1, 1, 0];
+      const vector2: number[] = [1, 0, 0];
+      // Normalized: [1/√2, 1/√2, 0] and [1, 0, 0]
+      // Dot product: 1/√2 ≈ 0.707
+      const similarity: number = 
+        LVS_VectorPool_ControlService.cosineSimilarity(vector1, vector2);
+      expect(similarity).toBeCloseTo(1 / Math.sqrt(2), 10);
+    });
+
+    it('| should handle zero vector', () => {
+      const vector1: number[] = [0, 0, 0];
+      const vector2: number[] = [1, 2, 3];
+      const similarity: number = 
+        LVS_VectorPool_ControlService.cosineSimilarity(vector1, vector2);
+      expect(similarity).toBeCloseTo(0, 10);
+    });
+  });
+
+  describe('| l2Distance (static)', () => {
+    it('| should return 0 for identical vectors', () => {
+      const vector: number[] = [1, 2, 3];
+      const distance: number = LVS_VectorPool_ControlService.l2Distance(vector, vector);
+      expect(distance).toBe(0);
+    });
+
+    it('| should throw error for vectors with different dimensions', () => {
+      const vector1: number[] = [1, 2, 3];
+      const vector2: number[] = [1, 2];
+
+      expect(() => {
+        LVS_VectorPool_ControlService.l2Distance(vector1, vector2);
+      }).toThrowError('Vectors must have the same dimension. Got 3 and 2');
+    });
+
+    it('| should calculate correct L2 distance for known vectors', () => {
+      const vector1: number[] = [0, 0, 0];
+      const vector2: number[] = [3, 4, 0];
+      // Distance = √(3² + 4² + 0²) = √25 = 5
+      const distance: number = LVS_VectorPool_ControlService.l2Distance(vector1, vector2);
+      expect(distance).toBe(5);
+    });
+
+    it('| should calculate correct L2 distance for 1D vectors', () => {
+      const vector1: number[] = [5];
+      const vector2: number[] = [2];
+      const distance: number = LVS_VectorPool_ControlService.l2Distance(vector1, vector2);
+      expect(distance).toBe(3);
+    });
+  });
+
+  describe('| search', () => {
+    beforeEach(() => {
+      // Add test vectors
+      vectorPool.addVector('vec1', [1, 0, 0]);
+      vectorPool.addVector('vec2', [0, 1, 0]);
+      vectorPool.addVector('vec3', [0, 0, 1]);
+      vectorPool.addVector('vec4', [1, 1, 0]);
+    });
+
+    it('| should return empty array for empty pool', () => {
+      const emptyPool: LVS_VectorPool_ControlService = new LVS_VectorPool_ControlService();
+      const results: LVS_SearchResult[] = emptyPool.search([1, 0, 0], 3, LVS_Search_Mode.cosineSimilarity);
+      expect(results.length).toBe(0);
+    });
+
+    it('| should return results in descending order for cosine similarity', () => {
+      const query: number[] = [1, 0, 0];
+      const results: LVS_SearchResult[] = vectorPool.search(
+        query, 
+        4, 
+        LVS_Search_Mode.cosineSimilarity
+      );
+
+      expect(results.length).toBe(4);
+      // vec1 should be most similar (identical)
+      expect(results[0].id).toBe('vec1');
+      expect(results[0].score).toBeCloseTo(1, 10);
+      // Results should be in descending order
+      for (let i: number = 0; i < results.length - 1; i++) {
+        expect(results[i].score).toBeGreaterThanOrEqual(results[i + 1].score);
+      }
+    });
+
+    it('| should return results in ascending order for L2 distance', () => {
+      const query: number[] = [1, 0, 0];
+      const results: LVS_SearchResult[] = vectorPool.search(
+        query, 
+        4, 
+        LVS_Search_Mode.l2Distance
+      );
+
+      expect(results.length).toBe(4);
+      // vec1 should be closest (distance = 0)
+      expect(results[0].id).toBe('vec1');
+      expect(results[0].score).toBe(0);
+      // Results should be in ascending order
+      for (let i: number = 0; i < results.length - 1; i++) {
+        expect(results[i].score).toBeLessThanOrEqual(results[i + 1].score);
+      }
+    });
+
+    it('| should limit results to top-K when k < pool size', () => {
+      const query: number[] = [1, 0, 0];
+      const results: LVS_SearchResult[] = vectorPool.search(
+        query, 
+        2, 
+        LVS_Search_Mode.cosineSimilarity
+      );
+
+      expect(results.length).toBe(2);
+    });
+
+    it('| should return all results when k > pool size', () => {
+      const query: number[] = [1, 0, 0];
+      const results: LVS_SearchResult[] = vectorPool.search(
+        query, 
+        10, 
+        LVS_Search_Mode.cosineSimilarity
+      );
+
+      expect(results.length).toBe(4);
+    });
+
+    it('| should return all results when k = pool size', () => {
+      const query: number[] = [1, 0, 0];
+      const results: LVS_SearchResult[] = vectorPool.search(
+        query, 
+        4, 
+        LVS_Search_Mode.cosineSimilarity
+      );
+
+      expect(results.length).toBe(4);
+    });
+
+    it('| should throw error for dimension mismatch', () => {
+      const query: number[] = [1, 0]; // 2D query, pool has 3D vectors
+
+      expect(() => {
+        vectorPool.search(query, 3, LVS_Search_Mode.cosineSimilarity);
+      }).toThrowError('Query vector dimension (2) does not match pool vector dimension (3)');
+    });
+
+    it('| should throw error for empty query vector', () => {
+      expect(() => {
+        vectorPool.search([], 3, LVS_Search_Mode.cosineSimilarity);
+      }).toThrowError('Query vector must be a non-empty array');
+    });
+
+    it('| should throw error for non-array query', () => {
+      expect(() => {
+        vectorPool.search(null as any, 3, LVS_Search_Mode.cosineSimilarity);
+      }).toThrowError('Query vector must be a non-empty array');
+    });
+
+    it('| should throw error for k = 0', () => {
+      expect(() => {
+        vectorPool.search([1, 0, 0], 0, LVS_Search_Mode.cosineSimilarity);
+      }).toThrowError('k must be a positive number');
+    });
+
+    it('| should throw error for negative k', () => {
+      expect(() => {
+        vectorPool.search([1, 0, 0], -1, LVS_Search_Mode.cosineSimilarity);
+      }).toThrowError('k must be a positive number');
+    });
+
+    it('| should throw error for unknown search mode', () => {
+      expect(() => {
+        vectorPool.search([1, 0, 0], 3, 'unknown-mode' as LVS_Search_Mode);
+      }).toThrowError('Unknown search mode: unknown-mode');
+    });
+
+    it('| should return correct scores for cosine similarity', () => {
+      const query: number[] = [1, 0, 0];
+      const results: LVS_SearchResult[] = vectorPool.search(
+        query, 
+        4, 
+        LVS_Search_Mode.cosineSimilarity
+      );
+
+      // vec1 should have score = 1 (identical)
+      const vec1Result: LVS_SearchResult | undefined =
+        results.find((r: LVS_SearchResult) => r.id === 'vec1');
+      expect(vec1Result).toBeDefined();
+      expect(vec1Result!.score).toBeCloseTo(1, 10);
+    });
+
+    it('| should produce cosine scores IDENTICAL to static cosineSimilarity (precomputed-normalized perf optimization, BFR-AM-013)', () => {
+      // Regression-guard: a search optimalizalt (precomputed-normalized + alloc-mentes) cosine-ja
+      // viselkedes-identikus a regi per-osszehasonlitas `cosineSimilarity(query, vector)`-ral.
+      const query: number[] = [0.3, 0.7, 0.2];
+      const results: LVS_SearchResult[] = vectorPool.search(query, 4, LVS_Search_Mode.cosineSimilarity);
+
+      expect(results.length).toBe(4);
+      const originals: Map<string, number[]> = vectorPool.getAll();
+      for (const result of results) {
+        const original: number[] | undefined = originals.get(result.id);
+        expect(original).toBeDefined();
+        const expected: number = LVS_VectorPool_ControlService.cosineSimilarity(query, original!);
+        expect(result.score).toBeCloseTo(expected, 10);
+      }
+    });
+
+    it('| should return correct scores for L2 distance', () => {
+      const query: number[] = [1, 0, 0];
+      const results: LVS_SearchResult[] = vectorPool.search(
+        query, 
+        4, 
+        LVS_Search_Mode.l2Distance
+      );
+
+      // vec1 should have score = 0 (identical)
+      const vec1Result: LVS_SearchResult | undefined =
+        results.find((r: LVS_SearchResult) => r.id === 'vec1');
+      expect(vec1Result).toBeDefined();
+      expect(vec1Result!.score).toBe(0);
+    });
+
+    it('| should restrict results to the candidateIds set (cosine)', () => {
+      const query: number[] = [1, 0, 0];
+      const candidateIds: Set<string> = new Set<string>(['vec2', 'vec3']);
+      const results: LVS_SearchResult[] = vectorPool.search(
+        query, 10, LVS_Search_Mode.cosineSimilarity, candidateIds
+      );
+      // CSAK a jelölt-halmaz ID-jai jelenhetnek meg (vec1/vec4 kizárva).
+      expect(results.length).toBe(2);
+      for (const r of results) {
+        expect(candidateIds.has(r.id)).toBe(true);
+      }
+    });
+
+    it('| should restrict results to the candidateIds set (L2)', () => {
+      const query: number[] = [1, 0, 0];
+      const candidateIds: Set<string> = new Set<string>(['vec1', 'vec4']);
+      const results: LVS_SearchResult[] = vectorPool.search(
+        query, 10, LVS_Search_Mode.l2Distance, candidateIds
+      );
+      expect(results.length).toBe(2);
+      expect(results.map((r: LVS_SearchResult) => r.id).sort()).toEqual(['vec1', 'vec4']);
+    });
+
+    it('| should give candidateId-scoped scores IDENTICAL to an unfiltered search filtered post-hoc', () => {
+      // A scoped keresés EREDMÉNYE (score-ok + sorrend) bit-azonos a teljes keresés azon
+      // részhalmazával, amit utólag a candidate-ID-kra szűrnénk — a szűrés csak SZŰKÍT, nem torzít.
+      const query: number[] = [1, 1, 0];
+      const candidateIds: Set<string> = new Set<string>(['vec1', 'vec2', 'vec4']);
+      const scoped: LVS_SearchResult[] = vectorPool.search(query, 10, LVS_Search_Mode.cosineSimilarity, candidateIds);
+      const full: LVS_SearchResult[] = vectorPool
+        .search(query, 10, LVS_Search_Mode.cosineSimilarity)
+        .filter((r: LVS_SearchResult) => candidateIds.has(r.id));
+      expect(scoped.length).toBe(full.length);
+      for (let i: number = 0; i < scoped.length; i++) {
+        expect(scoped[i].id).toBe(full[i].id);
+        expect(scoped[i].score).toBeCloseTo(full[i].score, 12);
+      }
+    });
+
+    it('| should return empty array for an empty candidateIds set', () => {
+      const results: LVS_SearchResult[] = vectorPool.search(
+        [1, 0, 0], 10, LVS_Search_Mode.cosineSimilarity, new Set<string>()
+      );
+      expect(results.length).toBe(0);
+    });
+  });
+
+  describe('| normalizedOnly mode (memory-optimized cosine-only pool)', () => {
+    let pool: LVS_VectorPool_ControlService;
+
+    beforeEach(() => {
+      pool = new LVS_VectorPool_ControlService({ normalizedOnly: true });
+      pool.addVector('vec1', [1, 0, 0]);
+      pool.addVector('vec2', [0, 1, 0]);
+      pool.addVector('vec3', [1, 1, 0]);
+    });
+
+    it('| should NOT store raw vectors (getAll empty) but size() correct', () => {
+      expect(pool.getAll().size).toBe(0);
+      expect(pool.size()).toBe(3);
+    });
+
+    it('| cosine search works identically to a normal pool', () => {
+      const normal: LVS_VectorPool_ControlService = new LVS_VectorPool_ControlService();
+      normal.addVector('vec1', [1, 0, 0]);
+      normal.addVector('vec2', [0, 1, 0]);
+      normal.addVector('vec3', [1, 1, 0]);
+
+      const query: number[] = [1, 0.2, 0];
+      const a: LVS_SearchResult[] = pool.search(query, 3, LVS_Search_Mode.cosineSimilarity);
+      const b: LVS_SearchResult[] = normal.search(query, 3, LVS_Search_Mode.cosineSimilarity);
+      expect(a.length).toBe(b.length);
+      for (let i: number = 0; i < a.length; i++) {
+        expect(a[i].id).toBe(b[i].id);
+        expect(a[i].score).toBeCloseTo(b[i].score, 12);
+      }
+    });
+
+    it('| cosine search honors candidateIds in normalizedOnly mode', () => {
+      const results: LVS_SearchResult[] = pool.search(
+        [1, 0, 0], 10, LVS_Search_Mode.cosineSimilarity, new Set<string>(['vec2', 'vec3'])
+      );
+      expect(results.length).toBe(2);
+      for (const r of results) {
+        expect(['vec2', 'vec3']).toContain(r.id);
+      }
+    });
+
+    it('| l2Distance throws in normalizedOnly mode (no raw vectors)', () => {
+      expect(() => pool.search([1, 0, 0], 3, LVS_Search_Mode.l2Distance))
+        .toThrowError(/normalizedOnly/);
+    });
+
+    it('| updateVector works (checks normalized pool, not raw)', () => {
+      expect(() => pool.updateVector('vec1', [0, 0, 1])).not.toThrow();
+      expect(() => pool.updateVector('missing', [0, 0, 1])).toThrowError(/does not exist/);
+    });
+  });
+});
+