@futdevpro/nts-dynamo 1.15.157 → 1.15.163

package/src/_modules/local-vector-search/_services/lvs-local-vector-search.data-service.ts

@@ -1,416 +0,0 @@
-import { DyFM_Log, DyFM_Error } from '@futdevpro/fsm-dynamo';
-import {
-  DyFM_DataModel_Params,
-  DyFM_DataProperty_Params,
-  DyFM_DBFilter,
-  DyFM_Metadata,
-} from '@futdevpro/fsm-dynamo';
-import { DyFM_OAI_Settings } from '@futdevpro/fsm-dynamo/ai/open-ai';
-
-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';
-import {
-  DyNTS_LVS_BM25_Corpus,
-  DyNTS_LVS_BM25_DocScore,
-  dyNTS_LVS_BM25_minMaxNormalize,
-} from './lvs-bm25.util';
-import { DyNTS_OAI_VectorDataService } from '../../ai/_modules/open-ai/_services/data-services/oai-vector-data.service';
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-
-/**
- * Local Vector Data Service
- * Extends {@link DyNTS_OAI_VectorDataService} to perform in-memory vector similarity search
- * instead of MongoDB vector search
- * 
- * This service loads data from the database, builds an in-memory vector pool,
- * and performs brute-force vector similarity search using cosine similarity or L2 distance
- * 
- * @example
- * ```typescript
- * const service = new DyNTS_OAI_LocalVectorDataService(
- *   data,
- *   dataParams,
- *   openAISettings,
- *   issuer
- * );
- * 
- * const results = await service.vectorSearch({
- *   input: 'search query',
- *   searchInKey: 'contentVectorized',
- *   limit: 10,
- *   filterBy: { category: 'docs' }
- * });
- * ```
- */
-export class DyNTS_LVS_VectorDataService<T extends DyFM_Metadata> extends DyNTS_OAI_VectorDataService<T> {
-
-  /**
-   * Default search mode
-   * Cosine similarity is typically preferred for text embeddings
-   */
-  defaultSearchMode: LVS_Search_Mode = LVS_Search_Mode.cosineSimilarity;
-
-  /**
-   * Whether to use L2 normalization when storing vectors
-   * Normalized vectors are more efficient for cosine similarity calculations
-   */
-  useL2Normalization: boolean = true;
-
-  /**
-   * Instance-based vector pool utility
-   * Minden service instance saját vektor pool-t tart fenn
-   */
-  private vectorPool: LVS_VectorPool_ControlService = new LVS_VectorPool_ControlService();
-
-  constructor(
-    /**
-     * Initial data, this will be used by functions on default
-     */
-    data: T,
-    /**
-     * DB data params will be used to connect to usable dbService on GlobalService
-     */
-    dataParams: DyFM_DataModel_Params<T>,
-    /**
-     * OpenAI settings
-     */
-    openAISettings: DyFM_OAI_Settings,
-    /**
-     * Initial set for issuer to be able to follow the issuer's activity
-     */
-    issuer: string
-  ) {
-    super(data, dataParams, openAISettings, issuer);
-  }
-
-  /**
-   * Overrides the parent vectorSearch method to perform local in-memory vector search
-   * 
-   * Process:
-   * 1. Load data from DB using filterBy (if provided) or getAll()
-   * 2. Extract vectorized properties from loaded data
-   * 3. Build in-memory vector pool
-   * 4. Vectorize input query
-   * 5. Perform local vector search
-   * 6. Map search results back to full data objects
-   * 
-   * @param set Search parameters
-   * @returns Array of data objects sorted by similarity score
-   */
-  override async vectorSearch(
-    set: {
-      input: string;
-      /** this should be the vectorized property key */
-      searchInKey: string;
-      limit?: number;
-      /**
-       * Number of candidates that are used to find the best match
-       * (Not used in local search, but kept for compatibility)
-       */
-      numberOfCandidates?: number;
-      /**
-       * Filter to narrow down candidates from DB before vector search
-       */
-      filterBy?: DyFM_DBFilter<T>;
-      /**
-       * Search mode (cosine similarity, L2 distance, or hybrid).
-       * Defaults to this.defaultSearchMode.
-       *
-       * `hybrid` mode combines cosine similarity (vector half) with BM25
-       * text scoring (text half) — `textSearchKey` is REQUIRED in hybrid mode.
-       */
-      searchMode?: LVS_Search_Mode;
-      /**
-       * Csak `hybrid` modban — weighted score-merge a cosine es a BM25 kozott.
-       * Default: { vector: 0.5, text: 0.5 }. Mindkettonek 0..1 tartomany javasolt.
-       */
-      hybridWeight?: { vector: number; text: number };
-      /**
-       * Csak `hybrid` modban — KOTELEZO; melyik string property-n fut a BM25
-       * text-search. NEM kell hogy a vectorized property legyen.
-       */
-      textSearchKey?: keyof T;
-    },
-  ): Promise<T[]> {
-    try {
-      if (!set.input) {
-        throw new DyFM_Error({
-          ...this.getDefaultErrorSettings(
-            'vectorSearch',
-            new Error('input is required')
-          ),
-          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-LVS-VS1`,
-        });
-      }
-
-      set.limit ??= 3;
-      const { input, searchInKey, limit, filterBy, searchMode, hybridWeight, textSearchKey } = set;
-      const effectiveMode: LVS_Search_Mode = searchMode ?? this.defaultSearchMode;
-
-      // Hybrid mode korai validacio
-      if (effectiveMode === LVS_Search_Mode.hybrid) {
-        if (!textSearchKey) {
-          throw new DyFM_Error({
-            ...this.getDefaultErrorSettings(
-              'vectorSearch',
-              new Error('textSearchKey is required when searchMode is hybrid'),
-            ),
-            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-LVS-VS4`,
-          });
-        }
-        if (hybridWeight) {
-          const w: { vector: number; text: number } = hybridWeight;
-          if (!Number.isFinite(w.vector) || !Number.isFinite(w.text) || w.vector < 0 || w.text < 0) {
-            throw new DyFM_Error({
-              ...this.getDefaultErrorSettings(
-                'vectorSearch',
-                new Error('hybridWeight.vector and .text must be non-negative finite numbers'),
-              ),
-              errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-LVS-VS5`,
-            });
-          }
-        }
-      }
-
-      // Validáljuk, hogy a searchInKey létezik-e
-      const property: DyFM_DataProperty_Params<any, T> = 
-        this.dataParams.properties[searchInKey];
-
-      if (!property) {
-        throw new DyFM_Error({
-          ...this.getDefaultErrorSettings(
-            'vectorSearch',
-            new Error(
-              `Property "${searchInKey}" not found! ` +
-              `while searching "${this.dataParams.dataName}" ` +
-              `(The searchable properties are: ` +
-              `${this.vectorizedProperties.map(p => `"${p.key}"`).join(', ')})`
-            )
-          ),
-          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-LVS-VS2`,
-          __localStack: this.dataParams.stackLocation,
-        });
-      }
-
-      // Ellenőrizzük, hogy a property vectorized-e
-      if (!this.vectorizedProperties.some(
-        (p: DyFM_DataProperty_Params<any, T>) => p.key === searchInKey
-      )) {
-        throw new DyFM_Error({
-          ...this.getDefaultErrorSettings(
-            'vectorSearch',
-            new Error(
-              `Property "${searchInKey}" is not a vectorized property! ` +
-              `(The vectorized properties are: ` +
-              `${this.vectorizedProperties.map(p => `"${p.key}"`).join(', ')})`
-            )
-          ),
-          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-LVS-VS3`,
-          __localStack: this.dataParams.stackLocation,
-        });
-      }
-
-      // 1. Betöltjük az adatokat a DB-ből (filterBy-val szűrve, ha van)
-      let dataList: T[];
-      if (filterBy) {
-        // Ha van filterBy, akkor először szűrünk a DB-ben
-        if (this.debugLog) {
-          DyFM_Log.log(`Local vector search: filtering data with filterBy...`);
-        }
-        dataList = await this.findDataList(filterBy, true);
-      } else {
-        // Ha nincs filterBy, akkor minden adatot betöltünk
-        if (this.debugLog) {
-          DyFM_Log.log(`Local vector search: loading all data...`);
-        }
-        dataList = await this.getAll(true);
-      }
-
-      if (dataList.length === 0) {
-        if (this.debugLog) {
-          DyFM_Log.log(`Local vector search: no data found`);
-        }
-        return [];
-      }
-
-      // 2. Kinyerjük a vectorized property-ket és építjük a vector pool-t
-      if (this.debugLog) {
-        DyFM_Log.log(
-          `Local vector search: building vector pool from ${dataList.length} items...`
-        );
-      }
-
-      // Töröljük a korábbi pool-t
-      this.vectorPool.clearPool();
-
-      // Hozzáadjuk a vektorokat a pool-hoz
-      const dataMap: Map<string, T> = new Map<string, T>();
-      for (const dataItem of dataList) {
-        if (!dataItem._id) {
-          // Ha nincs _id, akkor kihagyjuk
-          if (this.debugLog) {
-            DyFM_Log.warn(
-              `Local vector search: skipping item without _id`
-            );
-          }
-          continue;
-        }
-
-        const vectorizedValue: number[] | undefined = 
-          dataItem[searchInKey] as number[] | undefined;
-
-        if (!vectorizedValue || !Array.isArray(vectorizedValue)) {
-          // Ha nincs vectorized érték, akkor kihagyjuk
-          if (this.debugLog) {
-            DyFM_Log.warn(
-              `Local vector search: skipping item "${dataItem._id}" ` +
-              `without vectorized value for "${searchInKey}"`
-            );
-          }
-          continue;
-        }
-
-        // Hozzáadjuk a vektort a pool-hoz
-        this.vectorPool.addVector(dataItem._id, vectorizedValue);
-        dataMap.set(dataItem._id, dataItem);
-      }
-
-      if (dataMap.size === 0) {
-        if (this.debugLog) {
-          DyFM_Log.log(`Local vector search: no valid vectors found`);
-        }
-        return [];
-      }
-
-      // 3. Vectorizáljuk a query input-ot
-      if (this.debugLog) {
-        DyFM_Log.log(`Local vector search: vectorizing query input...`);
-      }
-
-      const queryVector: number[] = await this.vectorize(
-        input,
-        property.embeddingModel
-      );
-
-      // 4. Végrehajtjuk a local vector search-t
-      const mode: LVS_Search_Mode = effectiveMode;
-
-      if (this.debugLog) {
-        DyFM_Log.log(
-          `Local vector search: searching with mode "${mode}", limit: ${limit}...`
-        );
-      }
-
-      let searchResults: LVS_SearchResult[];
-
-      if (mode === LVS_Search_Mode.hybrid) {
-        // Hybrid: cosine ALL candidate-re + BM25 ALL candidate-re + min-max norm + weighted sum
-        const allCandidatesCosine: LVS_SearchResult[] = this.vectorPool.search(
-          queryVector,
-          dataMap.size,
-          LVS_Search_Mode.cosineSimilarity,
-        );
-
-        // BM25 corpus epitese a `textSearchKey` property-bol
-        const docs: { id: string; text: string }[] = [];
-        for (const [docId, dataItem] of dataMap) {
-          const textValue: unknown = dataItem[textSearchKey as keyof T];
-          docs.push({
-            id: docId,
-            text: typeof textValue === 'string' ? textValue : '',
-          });
-        }
-        const bm25Corpus: DyNTS_LVS_BM25_Corpus = new DyNTS_LVS_BM25_Corpus(docs);
-        const bm25Raw: DyNTS_LVS_BM25_DocScore[] = bm25Corpus.score(input);
-        const bm25Normalized: DyNTS_LVS_BM25_DocScore[] = dyNTS_LVS_BM25_minMaxNormalize(bm25Raw);
-
-        const bm25ScoreById: Map<string, number> = new Map<string, number>();
-        for (const s of bm25Normalized) {
-          bm25ScoreById.set(s.id, s.score);
-        }
-
-        const wVector: number = hybridWeight?.vector ?? 0.5;
-        const wText: number = hybridWeight?.text ?? 0.5;
-
-        const merged: LVS_SearchResult[] = allCandidatesCosine.map((c: LVS_SearchResult): LVS_SearchResult => {
-          const bm25Score: number = bm25ScoreById.get(c.id) ?? 0;
-          return {
-            id: c.id,
-            score: wVector * c.score + wText * bm25Score,
-          };
-        });
-        merged.sort((a: LVS_SearchResult, b: LVS_SearchResult) => b.score - a.score);
-        searchResults = merged.slice(0, limit);
-      } else {
-        searchResults = this.vectorPool.search(
-          queryVector,
-          limit,
-          mode,
-        );
-      }
-
-      if (this.debugLog) {
-        DyFM_Log.log(
-          `Local vector search: found ${searchResults.length} results`
-        );
-      }
-
-      // 5. Map-eljük vissza a search results-ot a teljes data objektumokra
-      const results: T[] = [];
-      for (const searchResult of searchResults) {
-        const dataItem: T | undefined = dataMap.get(searchResult.id);
-        if (dataItem) {
-          results.push(dataItem);
-        }
-      }
-
-      // Töröljük a pool-t a memória felszabadítása érdekében
-      this.vectorPool.clearPool();
-
-      return results;
-    } catch (error) {
-      // Töröljük a pool-t hiba esetén is
-      this.vectorPool.clearPool();
-
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('vectorSearch', error),
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-LVS-VS0`,
-      });
-    }
-  }
-}
-
-/**
- * @example
- * ```typescript
- * // Create a local vector data service
- * const localVectorService = new DyNTS_OAI_LocalVectorDataService<CodeChunk>(
- *   new CodeChunk(),
- *   codeChunk_dataParams,
- *   openAISettings,
- *   'example-issuer'
- * );
- * 
- * // Perform vector search with filterBy
- * const results = await localVectorService.vectorSearch({
- *   input: 'How to implement authentication?',
- *   searchInKey: 'chunkParentedContentVectorized',
- *   limit: 5,
- *   filterBy: {
- *     // Filter by category before vector search
- *     category: 'documentation'
- *   },
- *   searchMode: LVS_Search_Mode.cosineSimilarity
- * });
- * 
- * // Results are sorted by similarity score (highest first for cosine)
- * console.log(`Found ${results.length} similar chunks`);
- * 
- * // Access the results
- * for (const result of results) {
- *   console.log(`Chunk ID: ${result._id}, Content: ${result.chunkContent}`);
- * }
- * ```
- */
-

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

@@ -1,214 +0,0 @@
-
-import { DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-import { DyNTS_GlobalService } from '../../../_services/core/global.service';
-import { LVS_Search_Mode } from '../_enums/lvs-search-mode.enum';
-import { LVS_SearchResult } from '../_models/lvs-search-result.interface';
-import { DyNTS_LVS_VectorPersist } from '../_models/data-models/lvs-vector-persist.data-model';
-import { DyNTS_LVS_VectorPersist_DataService } from './lvs-vector-persist.data-service';
-import { DyNTS_LVS_PersistentVectorPool_ControlService } from './lvs-persistent-vector-pool.control-service';
-
-/**
- * BFR-AM-001 — a `DyNTS_LVS_PersistentVectorPool_ControlService` (kompozíció: in-memory pool + Mongo-persist) spec-jei.
- *
- * A DB-réteget egy IN-MEMORY fake-store helyettesíti: a `DyNTS_LVS_VectorPersist_DataService.prototype`
- * `upsertVector`/`removeVector`/`findByCollectionKey` metódusait stub-oljuk (a `getDBService` eager
- * base-ctor-t is, hogy a lazy data-service-példányok ne dobjanak — memory: dynts_dataservice_eager_resolve),
- * így a perzisztencia memóriában modellezett, ÉLŐ Mongo nélkül (skip-guard nem szükséges). A fő bizonyíték:
- * **persist-then-hydrate round-trip** újraépíti a VALÓDI `LVS_VectorPool_ControlService` in-memory indexét.
- */
-describe('| DyNTS_LVS_PersistentVectorPool_ControlService', () => {
-
-  let mockDBService: jasmine.SpyObj<{ find: () => Promise<unknown[]>; findOne: () => Promise<unknown> }>;
-
-  /** Fake tartós tár: `collectionKey` → (`vectorId` → rekord). A persist-stubok ezt írják/olvassák. */
-  let store: Map<string, Map<string, DyNTS_LVS_VectorPersist>>;
-
-  beforeAll(() => {
-    if (!DyNTS_global_settings.systemShortCodeName) {
-      (DyNTS_global_settings as { systemShortCodeName?: string }).systemShortCodeName = 'TEST';
-    }
-    if (!DyNTS_global_settings.env_settings) {
-      (DyNTS_global_settings as { env_settings?: unknown }).env_settings = {
-        environment: DyFM_EnvironmentFlag.local,
-      };
-    }
-  });
-
-  beforeEach(() => {
-    // A base-ctor eager getDBService-jét stub-oljuk (a lazy persist-service ne dobjon).
-    mockDBService = jasmine.createSpyObj('DyNTS_DBService', ['find', 'findOne']);
-    mockDBService.find.and.returnValue(Promise.resolve([]));
-    mockDBService.findOne.and.returnValue(Promise.resolve(null));
-    spyOn(DyNTS_GlobalService, 'getDBService').and.returnValue(mockDBService as never);
-
-    // A fake tartós tár + a persist-service prototype-stubok (memóriában modellezett Mongo).
-    store = new Map<string, Map<string, DyNTS_LVS_VectorPersist>>();
-
-    spyOn(DyNTS_LVS_VectorPersist_DataService.prototype, 'upsertVector').and.callFake(
-      (set: { collectionKey: string; vectorId: string; embedding: number[]; metadata?: unknown }) => {
-        let coll: Map<string, DyNTS_LVS_VectorPersist> | undefined = store.get(set.collectionKey);
-        if (!coll) {
-          coll = new Map<string, DyNTS_LVS_VectorPersist>();
-          store.set(set.collectionKey, coll);
-        }
-        coll.set(set.vectorId, new DyNTS_LVS_VectorPersist({
-          collectionKey: set.collectionKey,
-          vectorId: set.vectorId,
-          embedding: set.embedding,
-          dimensions: set.embedding.length,
-          metadata: set.metadata,
-        }));
-        return Promise.resolve();
-      },
-    );
-
-    spyOn(DyNTS_LVS_VectorPersist_DataService.prototype, 'removeVector').and.callFake(
-      (collectionKey: string, vectorId: string) => {
-        store.get(collectionKey)?.delete(vectorId);
-        return Promise.resolve();
-      },
-    );
-
-    spyOn(DyNTS_LVS_VectorPersist_DataService.prototype, 'findByCollectionKey').and.callFake(
-      (collectionKey: string) =>
-        Promise.resolve(Array.from(store.get(collectionKey)?.values() ?? [])),
-    );
-
-    // BFR-AM-013 (hydration-paging): a batch-elt lean-scan fake-je — a fake-store tartalmát
-    // batch-enként adagolja a handler-nek (a valós cursor-viselkedés memóriában modellezve).
-    spyOn(DyNTS_LVS_VectorPersist_DataService.prototype, 'findLeanBatchedByCollectionKey').and.callFake(
-      async (
-        collectionKey: string,
-        set: { batchSize?: number; handler: (batch: Partial<DyNTS_LVS_VectorPersist>[]) => Promise<void> | void },
-      ): Promise<number> => {
-        const all: DyNTS_LVS_VectorPersist[] = Array.from(store.get(collectionKey)?.values() ?? []);
-        const batchSize: number = set.batchSize && set.batchSize > 0 ? set.batchSize : 500;
-        for (let i: number = 0; i < all.length; i += batchSize) {
-          await set.handler(all.slice(i, i + batchSize));
-        }
-        return all.length;
-      },
-    );
-  });
-
-  /** Egy egységvektor a tengely-irányba (cosine-self = 1) — determinisztikus keresés-ellenőrzéshez. */
-  const axis = (dim: number, hot: number): number[] => {
-    const v: number[] = new Array<number>(dim).fill(0);
-    v[hot] = 1;
-    return v;
-  };
-
-  it('| should persist on addVector and store the dimension', async () => {
-    const pool: DyNTS_LVS_PersistentVectorPool_ControlService =
-      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-a', issuer: 'test' });
-
-    await pool.addVector('v1', [0.1, 0.2, 0.3], { tag: 'x' });
-
-    const persisted: DyNTS_LVS_VectorPersist | undefined = store.get('pool-a')?.get('v1');
-    expect(persisted).toBeDefined();
-    expect(persisted.embedding).toEqual([0.1, 0.2, 0.3]);
-    expect(persisted.dimensions).toBe(3);
-    expect(persisted.metadata).toEqual({ tag: 'x' });
-    // és a memória-pool-ban is benne van (kereshető):
-    expect(pool.getPool().getAll().size).toBe(1);
-  });
-
-  it('| persist-then-hydrate round-trip rebuilds the in-memory pool', async () => {
-    // (1) Egy pool-ba 3 vektort persistálunk.
-    const writer: DyNTS_LVS_PersistentVectorPool_ControlService =
-      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-a', issuer: 'test' });
-    await writer.addVector('v0', axis(4, 0));
-    await writer.addVector('v1', axis(4, 1));
-    await writer.addVector('v2', axis(4, 2));
-    expect(store.get('pool-a').size).toBe(3);
-
-    // (2) Egy FRISS wrapper (üres memória-pool) — szerver-restart szimuláció.
-    const rebuilt: DyNTS_LVS_PersistentVectorPool_ControlService =
-      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-a', issuer: 'test' });
-    expect(rebuilt.getPool().getAll().size).toBe(0);
-
-    // (3) Hidratálás Mongo-ból → a memória-pool újraépül.
-    const loaded: number = await rebuilt.hydrateFromMongo();
-    expect(loaded).toBe(3);
-    expect(rebuilt.getPool().getAll().size).toBe(3);
-
-    // (4) A keresés a hidratált pool-on a helyes vektort hozza vissza (cosine self-match = 1).
-    const hits: LVS_SearchResult[] = rebuilt.search(axis(4, 1), 1, LVS_Search_Mode.cosineSimilarity);
-    expect(hits.length).toBe(1);
-    expect(hits[0].id).toBe('v1');
-    expect(hits[0].score).toBeCloseTo(1, 6);
-  });
-
-  it('| should only hydrate the matching collectionKey (pool partitioning)', async () => {
-    const a: DyNTS_LVS_PersistentVectorPool_ControlService =
-      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-a', issuer: 'test' });
-    const b: DyNTS_LVS_PersistentVectorPool_ControlService =
-      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-b', issuer: 'test' });
-
-    await a.addVector('a1', axis(3, 0));
-    await b.addVector('b1', axis(3, 1));
-    await b.addVector('b2', axis(3, 2));
-
-    const rebuiltA: DyNTS_LVS_PersistentVectorPool_ControlService =
-      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-a', issuer: 'test' });
-    expect(await rebuiltA.hydrateFromMongo()).toBe(1);
-    expect(Array.from(rebuiltA.getPool().getAll().keys())).toEqual(['a1']);
-  });
-
-  it('| upsert (re-add) is reflected in both the pool and the store', async () => {
-    const pool: DyNTS_LVS_PersistentVectorPool_ControlService =
-      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-a', issuer: 'test' });
-
-    await pool.addVector('v1', [1, 0, 0]);
-    await pool.updateVector('v1', [0, 1, 0], { v: 2 });
-
-    // a tárban EGY rekord van, a frissített értékkel + dimenzióval:
-    expect(store.get('pool-a').size).toBe(1);
-    const persisted: DyNTS_LVS_VectorPersist = store.get('pool-a').get('v1');
-    expect(persisted.embedding).toEqual([0, 1, 0]);
-    expect(persisted.dimensions).toBe(3);
-    expect(persisted.metadata).toEqual({ v: 2 });
-
-    // és egy friss hidratálás a frissített vektort hozza:
-    const rebuilt: DyNTS_LVS_PersistentVectorPool_ControlService =
-      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-a', issuer: 'test' });
-    await rebuilt.hydrateFromMongo();
-    const hits: LVS_SearchResult[] = rebuilt.search([0, 1, 0], 1, LVS_Search_Mode.cosineSimilarity);
-    expect(hits[0].id).toBe('v1');
-    expect(hits[0].score).toBeCloseTo(1, 6);
-  });
-
-  it('| removeVector is reflected in both the pool and the store', async () => {
-    const pool: DyNTS_LVS_PersistentVectorPool_ControlService =
-      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-a', issuer: 'test' });
-
-    await pool.addVector('v1', axis(3, 0));
-    await pool.addVector('v2', axis(3, 1));
-    expect(store.get('pool-a').size).toBe(2);
-
-    await pool.removeVector('v1');
-
-    expect(store.get('pool-a').size).toBe(1);
-    expect(store.get('pool-a').has('v1')).toBeFalse();
-    expect(pool.getPool().getAll().has('v1')).toBeFalse();
-    expect(pool.getPool().getAll().has('v2')).toBeTrue();
-  });
-
-  it('| hydrate(records) rebuilds the pool without a Mongo read and skips incomplete records', () => {
-    const pool: DyNTS_LVS_PersistentVectorPool_ControlService =
-      new DyNTS_LVS_PersistentVectorPool_ControlService({ collectionKey: 'pool-a', issuer: 'test' });
-
-    const loaded: number = pool.hydrate([
-      new DyNTS_LVS_VectorPersist({ collectionKey: 'pool-a', vectorId: 'v1', embedding: axis(2, 0) }),
-      new DyNTS_LVS_VectorPersist({ collectionKey: 'pool-a', vectorId: 'v2', embedding: axis(2, 1) }),
-      // hiányos rekordok (átugorva):
-      new DyNTS_LVS_VectorPersist({ collectionKey: 'pool-a', vectorId: 'v3', embedding: [] }),
-      new DyNTS_LVS_VectorPersist({ collectionKey: 'pool-a', embedding: axis(2, 0) }),
-    ]);
-
-    expect(loaded).toBe(2);
-    expect(pool.getPool().getAll().size).toBe(2);
-  });
-});