@futdevpro/nts-dynamo 1.15.58 → 1.15.64

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

@@ -5,12 +5,12 @@ import { DyNTS_global_settings } from '../../../_collections/global-settings.con
 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_DataModel } from '../_models/data-models/lvs-vector-persist.data-model';
+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 } from './lvs-persistent-vector-pool.control-service';
+import { DyNTS_LVS_PersistentVectorPool_ControlService } from './lvs-persistent-vector-pool.control-service';
 
 /**
- * BFR-AM-001 — a `DyNTS_LVS_PersistentVectorPool` (kompozíció: in-memory pool + Mongo-persist) spec-jei.
+ * 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
@@ -18,12 +18,12 @@ import { DyNTS_LVS_PersistentVectorPool } from './lvs-persistent-vector-pool.con
  * í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', () => {
+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_DataModel>>;
+  let store: Map<string, Map<string, DyNTS_LVS_VectorPersist>>;
 
   beforeAll(() => {
     if (!DyNTS_global_settings.systemShortCodeName) {
@@ -44,16 +44,16 @@ describe('| DyNTS_LVS_PersistentVectorPool', () => {
     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_DataModel>>();
+    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_DataModel> | undefined = store.get(set.collectionKey);
+        let coll: Map<string, DyNTS_LVS_VectorPersist> | undefined = store.get(set.collectionKey);
         if (!coll) {
-          coll = new Map<string, DyNTS_LVS_VectorPersist_DataModel>();
+          coll = new Map<string, DyNTS_LVS_VectorPersist>();
           store.set(set.collectionKey, coll);
         }
-        coll.set(set.vectorId, new DyNTS_LVS_VectorPersist_DataModel({
+        coll.set(set.vectorId, new DyNTS_LVS_VectorPersist({
           collectionKey: set.collectionKey,
           vectorId: set.vectorId,
           embedding: set.embedding,
@@ -85,12 +85,12 @@ describe('| DyNTS_LVS_PersistentVectorPool', () => {
   };
 
   it('| should persist on addVector and store the dimension', async () => {
-    const pool: DyNTS_LVS_PersistentVectorPool =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-a', issuer: 'test' });
+    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_DataModel | undefined = store.get('pool-a')?.get('v1');
+    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);
@@ -101,16 +101,16 @@ describe('| DyNTS_LVS_PersistentVectorPool', () => {
 
   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 =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-a', issuer: 'test' });
+    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 =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-a', issuer: 'test' });
+    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.
@@ -126,38 +126,38 @@ describe('| DyNTS_LVS_PersistentVectorPool', () => {
   });
 
   it('| should only hydrate the matching collectionKey (pool partitioning)', async () => {
-    const a: DyNTS_LVS_PersistentVectorPool =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-a', issuer: 'test' });
-    const b: DyNTS_LVS_PersistentVectorPool =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-b', issuer: 'test' });
+    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 =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-a', issuer: 'test' });
+    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 =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-a', issuer: 'test' });
+    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_DataModel = store.get('pool-a').get('v1');
+    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 =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-a', issuer: 'test' });
+    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');
@@ -165,8 +165,8 @@ describe('| DyNTS_LVS_PersistentVectorPool', () => {
   });
 
   it('| removeVector is reflected in both the pool and the store', async () => {
-    const pool: DyNTS_LVS_PersistentVectorPool =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-a', issuer: 'test' });
+    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));
@@ -181,15 +181,15 @@ describe('| DyNTS_LVS_PersistentVectorPool', () => {
   });
 
   it('| hydrate(records) rebuilds the pool without a Mongo read and skips incomplete records', () => {
-    const pool: DyNTS_LVS_PersistentVectorPool =
-      new DyNTS_LVS_PersistentVectorPool({ collectionKey: 'pool-a', issuer: 'test' });
+    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_DataModel({ collectionKey: 'pool-a', vectorId: 'v1', embedding: axis(2, 0) }),
-      new DyNTS_LVS_VectorPersist_DataModel({ collectionKey: 'pool-a', vectorId: 'v2', embedding: axis(2, 1) }),
+      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_DataModel({ collectionKey: 'pool-a', vectorId: 'v3', embedding: [] }),
-      new DyNTS_LVS_VectorPersist_DataModel({ collectionKey: 'pool-a', embedding: axis(2, 0) }),
+      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);

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

@@ -3,12 +3,12 @@ import { DyFM_Log } from '@futdevpro/fsm-dynamo';
 
 import { LVS_Search_Mode } from '../_enums/lvs-search-mode.enum';
 import { LVS_SearchResult } from '../_models/lvs-search-result.interface';
-import { DyNTS_LVS_VectorPersist_DataModel } from '../_models/data-models/lvs-vector-persist.data-model';
+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 { LVS_VectorPool_ControlService } from './lvs-vector-pool.control-service';
 
 /**
- * `DyNTS_LVS_PersistentVectorPool` (BFR-AM-001) — egy `LVS_VectorPool_ControlService` in-memory pool +
+ * `DyNTS_LVS_PersistentVectorPool_ControlService` (BFR-AM-001) — egy `LVS_VectorPool_ControlService` in-memory pool +
  * MongoDB-perzisztencia **kompozíciója**. A FAM (fdp-agent-memory) `FAM_VectorSearch_ControlService`
  * persist+hydrate workaround-ját generalizálja bedrock-szintre: a vektorok a SAJÁT Mongo-ban
  * (`dynts_lvs_vector`) élnek, boot-kor a memória-pool-ba hidratálódnak — **NEM** MongoDB Atlas
@@ -24,7 +24,7 @@ import { LVS_VectorPool_ControlService } from './lvs-vector-pool.control-service
  * `getDBService`-t hív, ezért a wrapper NEM tart élő data-service-mezőt — minden DB-művelet előtt lazy
  * `new DyNTS_LVS_VectorPersist_DataService(...)` (a `getPersistService` ezt adja).
  */
-export class DyNTS_LVS_PersistentVectorPool {
+export class DyNTS_LVS_PersistentVectorPool_ControlService {
 
   /** A wrapped in-memory pool (a Dynamo LVS engine; VÁLTOZATLAN — kompozíció, nem módosítás). */
   private readonly pool: LVS_VectorPool_ControlService;
@@ -98,12 +98,13 @@ export class DyNTS_LVS_PersistentVectorPool {
    * Visszaadja a betöltött vektorok számát. **NEM** Atlas — saját Mongo + in-memory pool.
    */
   async hydrateFromMongo(): Promise<number> {
-    const records: DyNTS_LVS_VectorPersist_DataModel[] =
+    const records: DyNTS_LVS_VectorPersist[] =
       await this.getPersistService().findByCollectionKey(this.collectionKey);
 
     this.pool.clearPool();
 
     let loaded: number = 0;
+
     for (const record of records) {
       if (!record.vectorId || !record.embedding?.length) {
         continue;
@@ -115,6 +116,7 @@ export class DyNTS_LVS_PersistentVectorPool {
     DyFM_Log.log(
       `[DyNTS LVS hydrate] '${this.collectionKey}' pool: ${loaded} vektor betöltve az in-memory pool-ba.`,
     );
+
     return loaded;
   }
 
@@ -123,9 +125,10 @@ export class DyNTS_LVS_PersistentVectorPool {
    * kezében van a rekord-halmaz (pl. batch-boot). A pool-t előbb üríti (idempotens). Visszaadja a
    * betöltött vektorok számát.
    */
-  hydrate(records: DyNTS_LVS_VectorPersist_DataModel[]): number {
+  hydrate(records: DyNTS_LVS_VectorPersist[]): number {
     this.pool.clearPool();
     let loaded: number = 0;
+
     for (const record of records) {
       if (!record.vectorId || !record.embedding?.length) {
         continue;
@@ -133,6 +136,7 @@ export class DyNTS_LVS_PersistentVectorPool {
       this.pool.addVector(record.vectorId, record.embedding);
       loaded++;
     }
+
     return loaded;
   }
 

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

@@ -3,7 +3,7 @@ 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 { DyNTS_LVS_VectorPersist_DataModel } from '../_models/data-models/lvs-vector-persist.data-model';
+import { DyNTS_LVS_VectorPersist } from '../_models/data-models/lvs-vector-persist.data-model';
 import { DyNTS_LVS_VectorPersist_DataService } from './lvs-vector-persist.data-service';
 
 /**
@@ -36,7 +36,7 @@ describe('| DyNTS_LVS_VectorPersist_DataService', () => {
   describe('| constructor', () => {
 
     it('| should create the service with a data model', () => {
-      const data: DyNTS_LVS_VectorPersist_DataModel = new DyNTS_LVS_VectorPersist_DataModel({
+      const data: DyNTS_LVS_VectorPersist = new DyNTS_LVS_VectorPersist({
         collectionKey: 'pool-a',
         vectorId: 'v1',
         embedding: [1, 2, 3],
@@ -56,7 +56,7 @@ describe('| DyNTS_LVS_VectorPersist_DataService', () => {
         new DyNTS_LVS_VectorPersist_DataService({ issuer: 'issuer-123' });
 
       expect(service).toBeInstanceOf(DyNTS_LVS_VectorPersist_DataService);
-      expect(service.data).toBeInstanceOf(DyNTS_LVS_VectorPersist_DataModel);
+      expect(service.data).toBeInstanceOf(DyNTS_LVS_VectorPersist);
     });
   });
 
@@ -66,12 +66,12 @@ describe('| DyNTS_LVS_VectorPersist_DataService', () => {
       const service: DyNTS_LVS_VectorPersist_DataService =
         new DyNTS_LVS_VectorPersist_DataService({ issuer: 'issuer-123' });
 
-      const records: DyNTS_LVS_VectorPersist_DataModel[] = [
-        new DyNTS_LVS_VectorPersist_DataModel({ collectionKey: 'pool-a', vectorId: 'v1', embedding: [1, 0] }),
+      const records: DyNTS_LVS_VectorPersist[] = [
+        new DyNTS_LVS_VectorPersist({ collectionKey: 'pool-a', vectorId: 'v1', embedding: [1, 0] }),
       ];
       const findSpy = spyOn(service, 'findDataList').and.returnValue(Promise.resolve(records));
 
-      const result: DyNTS_LVS_VectorPersist_DataModel[] = await service.findByCollectionKey('pool-a');
+      const result: DyNTS_LVS_VectorPersist[] = await service.findByCollectionKey('pool-a');
 
       expect(findSpy).toHaveBeenCalledTimes(1);
       const filterArg = findSpy.calls.mostRecent().args[0] as { collectionKey: string };
@@ -86,7 +86,7 @@ describe('| DyNTS_LVS_VectorPersist_DataService', () => {
       const service: DyNTS_LVS_VectorPersist_DataService =
         new DyNTS_LVS_VectorPersist_DataService({ issuer: 'issuer-123' });
 
-      const existing: DyNTS_LVS_VectorPersist_DataModel = new DyNTS_LVS_VectorPersist_DataModel({
+      const existing: DyNTS_LVS_VectorPersist = new DyNTS_LVS_VectorPersist({
         collectionKey: 'pool-a', vectorId: 'v1', embedding: [1, 2, 3],
       });
       existing._id = 'rec-1';
@@ -118,14 +118,14 @@ describe('| DyNTS_LVS_VectorPersist_DataService', () => {
       spyOn(service, 'findData').and.returnValue(Promise.resolve(null));
       const updateSpy = spyOn(service, 'updateData').and.returnValue(Promise.resolve());
       const saveSpy = spyOn(service, 'saveData')
-        .and.callFake((data?: DyNTS_LVS_VectorPersist_DataModel) =>
-          Promise.resolve(data as DyNTS_LVS_VectorPersist_DataModel));
+        .and.callFake((data?: DyNTS_LVS_VectorPersist) =>
+          Promise.resolve(data as DyNTS_LVS_VectorPersist));
 
       await service.upsertVector({ collectionKey: 'pool-a', vectorId: 'v2', embedding: [0.1, 0.2] });
 
       expect(updateSpy).not.toHaveBeenCalled();
       expect(saveSpy).toHaveBeenCalledTimes(1);
-      const written = saveSpy.calls.mostRecent().args[0] as DyNTS_LVS_VectorPersist_DataModel;
+      const written = saveSpy.calls.mostRecent().args[0] as DyNTS_LVS_VectorPersist;
       expect(written.vectorId).toBe('v2');
       expect(written.collectionKey).toBe('pool-a');
       expect(written.embedding).toEqual([0.1, 0.2]);
@@ -139,7 +139,7 @@ describe('| DyNTS_LVS_VectorPersist_DataService', () => {
       const service: DyNTS_LVS_VectorPersist_DataService =
         new DyNTS_LVS_VectorPersist_DataService({ issuer: 'issuer-123' });
 
-      const existing: DyNTS_LVS_VectorPersist_DataModel = new DyNTS_LVS_VectorPersist_DataModel({
+      const existing: DyNTS_LVS_VectorPersist = new DyNTS_LVS_VectorPersist({
         collectionKey: 'pool-a', vectorId: 'v1', embedding: [1, 0],
       });
       existing._id = 'rec-1';

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

@@ -3,8 +3,8 @@ import { DyFM_DBFilter, DyFM_DBFilterSimple } from '@futdevpro/fsm-dynamo';
 
 import { DyNTS_DataService } from '../../../_services/base/data.service';
 import {
-  DyNTS_LVS_VectorPersist_DataModel,
-  dyNTS_lvsVectorPersist_dataParams,
+  DyNTS_LVS_VectorPersist,
+  DyNTS_lvsVectorPersist_dataParams
 } from '../_models/data-models/lvs-vector-persist.data-model';
 
 /**
@@ -14,36 +14,36 @@ import {
  *
  * **FIGYELEM (memory: dynts_dataservice_eager_resolve):** a `DyNTS_DataService` base-ctor EAGER
  * `getDBService`-t hív → a hívó NEM tarthat élő data-service-példányt mezőként; minden művelet előtt
- * lazy `new DyNTS_LVS_VectorPersist_DataService(...)` kell (a `DyNTS_LVS_PersistentVectorPool` így jár el).
+ * lazy `new DyNTS_LVS_VectorPersist_DataService(...)` kell (a `DyNTS_LVS_PersistentVectorPool_ControlService` így jár el).
  *
  * **Atomikus írás (memory: mongoose_mixed_atomic_write):** az upsert a `(collectionKey, vectorId)`
  * logikai-kulcson MEGLÉVŐ rekordot `updateOne({...},{$set:{embedding,dimensions,metadata}})`-tel
  * frissíti (a Mixed `metadata` `findOne→mutate→save` SILENT-DROP-ja ellen); ÚJ rekordot `saveData`-val ír.
  */
-export class DyNTS_LVS_VectorPersist_DataService extends DyNTS_DataService<DyNTS_LVS_VectorPersist_DataModel> {
+export class DyNTS_LVS_VectorPersist_DataService extends DyNTS_DataService<DyNTS_LVS_VectorPersist> {
 
   constructor(
     set: {
-      data?: DyNTS_LVS_VectorPersist_DataModel,
+      data?: DyNTS_LVS_VectorPersist,
       issuer: string,
     },
   ) {
     super(
-      set.data instanceof DyNTS_LVS_VectorPersist_DataModel
+      set.data instanceof DyNTS_LVS_VectorPersist
         ? set.data
-        : new DyNTS_LVS_VectorPersist_DataModel(set.data),
-      dyNTS_lvsVectorPersist_dataParams,
+        : new DyNTS_LVS_VectorPersist(set.data),
+      DyNTS_lvsVectorPersist_dataParams,
       set.issuer,
     );
   }
 
   /**
    * Egy (logikai) pool ÖSSZES perzistált, nem-soft-delete-elt vektor-rekordja — a boot-hidratáláshoz
-   * (a `DyNTS_LVS_PersistentVectorPool.hydrateFromMongo` ezt tölti az in-memory pool-ba).
+   * (a `DyNTS_LVS_PersistentVectorPool_ControlService.hydrateFromMongo` ezt tölti az in-memory pool-ba).
    */
-  async findByCollectionKey(collectionKey: string): Promise<DyNTS_LVS_VectorPersist_DataModel[]> {
+  async findByCollectionKey(collectionKey: string): Promise<DyNTS_LVS_VectorPersist[]> {
     return this.findDataList(
-      { collectionKey: collectionKey } as DyFM_DBFilterSimple<DyNTS_LVS_VectorPersist_DataModel>,
+      { collectionKey: collectionKey },
       true,
     );
   }
@@ -59,14 +59,14 @@ export class DyNTS_LVS_VectorPersist_DataService extends DyNTS_DataService<DyNTS
     embedding: number[],
     metadata?: unknown,
   }): Promise<void> {
-    const existing: DyNTS_LVS_VectorPersist_DataModel = await this.findData(
-      { collectionKey: set.collectionKey, vectorId: set.vectorId } as DyFM_DBFilter<DyNTS_LVS_VectorPersist_DataModel>,
+    const existing: DyNTS_LVS_VectorPersist = await this.findData(
+      { collectionKey: set.collectionKey, vectorId: set.vectorId },
       true,
     );
 
     if (existing?._id) {
       await this.updateData({
-        filterBy: { _id: existing._id } as DyFM_DBFilterSimple<DyNTS_LVS_VectorPersist_DataModel>,
+        filterBy: { _id: existing._id },
         update: {
           $set: {
             embedding: set.embedding,
@@ -75,11 +75,12 @@ export class DyNTS_LVS_VectorPersist_DataService extends DyNTS_DataService<DyNTS
           },
         },
       });
+
       return;
     }
 
     await this.saveData(
-      new DyNTS_LVS_VectorPersist_DataModel({
+      new DyNTS_LVS_VectorPersist({
         collectionKey: set.collectionKey,
         vectorId: set.vectorId,
         embedding: set.embedding,
@@ -95,10 +96,11 @@ export class DyNTS_LVS_VectorPersist_DataService extends DyNTS_DataService<DyNTS
    * `removeVector`-ja után — a tartós tár is törli). `addArchive` nincs → `absolute` true-val töröl.
    */
   async removeVector(collectionKey: string, vectorId: string): Promise<void> {
-    const existing: DyNTS_LVS_VectorPersist_DataModel = await this.findData(
-      { collectionKey: collectionKey, vectorId: vectorId } as DyFM_DBFilter<DyNTS_LVS_VectorPersist_DataModel>,
+    const existing: DyNTS_LVS_VectorPersist = await this.findData(
+      { collectionKey: collectionKey, vectorId: vectorId },
       true,
     );
+
     if (existing?._id) {
       await this.deleteData(existing._id, true);
     }

package/src/_modules/mcp/_models/interfaces/dynts-mcp.interface.ts

@@ -5,7 +5,7 @@
  *
  * Boundary: a `DyNTS_McpToolDefinition` + a `DyNTS_Mcp_Adapter` egyetlen `registerTool` choke-pontot
  * ad — a hivatalos `@modelcontextprotocol/sdk` KIZÁRÓLAG az adaptor mögött él, így egy jövőbeli
- * transport-/SDK-csere NEM-breaking (csak az adaptor cserélődik, a `DyNTS_Mcp_ServerBase` + a
+ * transport-/SDK-csere NEM-breaking (csak az adaptor cserélődik, a `DyNTS_Mcp_Server_ServiceBase` + a
  * consumer-tool-ok változatlanok). A consumer a SAJÁT tool-jait regisztrálja (a bedrock NEM definiál
  * domain-tool-okat — csak a server-base + a transport + a registry).
  */