@futdevpro/nts-dynamo 1.15.64 → 1.15.68

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

@@ -1,70 +1,70 @@
-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 { LVS_VectorPool_ControlService } from './lvs-vector-pool.control-service';
-/**
- * `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
- * Vector Search.
- *
- * **Miért KOMPOZÍCIÓ (NEM a pool-class módosítása):** a `LVS_VectorPool_ControlService`-t egy másik,
- * párhuzamos WIP (hybrid cosine+BM25) is érinti; a pool-class változtatása merge-konfliktust okozna.
- * Ez a wrapper a pool-t VÁLTOZATLANUL hagyja (delegál: `addVector`/`removeVector`/`updateVector`/
- * `search`), és a perzisztencia-mellékhatást a wrapper-metódusokban végzi. Egy wrapper-instance egy
- * `collectionKey` (logikai pool); több pool = több wrapper.
- *
- * **FIGYELEM (memory: dynts_dataservice_eager_resolve):** a `DyNTS_DataService` base-ctor EAGER
- * `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 declare 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;
-    /** A pool-particionálás kulcsa (a Mongo-rekordok `collectionKey`-e + a hidratálás-szűrő). */
-    private readonly collectionKey;
-    /** A perzisztencia-műveletek issuer-e (audit). */
-    private readonly issuer;
-    constructor(set: {
-        collectionKey: string;
-        issuer: string;
-        pool?: LVS_VectorPool_ControlService;
-    });
-    /** A wrapped in-memory pool (közvetlen olvasáshoz — pl. más search-mód, getAll). */
-    getPool(): LVS_VectorPool_ControlService;
-    /**
-     * Egy vektor felvétele a memória-pool-ba ÉS tartós upsert-je Mongo-ba (persist-on-write, FAM-minta).
-     * A pool `addVector`-ja upsert-szemantikájú (azonos kulcson felülír), a Mongo-oldal is `(collectionKey,
-     * vectorId)`-upsert. A Mongo-írás MELLÉKHATÁS a memória-művelet után (a memória a forrás, a Mongo a tár).
-     */
-    addVector(vectorId: string, vector: number[], metadata?: unknown): Promise<void>;
-    /**
-     * Egy MEGLÉVŐ vektor frissítése a memória-pool-ban + tartós upsert Mongo-ba. A pool `updateVector`-ja
-     * dob, ha a kulcs nem létezik (a pool-szerződés változatlan) — a Mongo-írás csak siker után fut.
-     */
-    updateVector(vectorId: string, vector: number[], metadata?: unknown): Promise<void>;
-    /** Egy vektor eltávolítása a memória-pool-ból ÉS a tartós tárból (`(collectionKey, vectorId)`). */
-    removeVector(vectorId: string): Promise<void>;
-    /** Keresés a memória-pool-on (a wrapped pool `search`-jét delegálja — VÁLTOZATLAN engine). */
-    search(query: number[], k: number, mode: LVS_Search_Mode): LVS_SearchResult[];
-    /**
-     * BOOT-HIDRATÁLÁS (FAM-minta, BFR-AM-001): a `collectionKey` ÖSSZES perzistált vektorát betölti a
-     * MEMÓRIA-pool-ba (`pool.addVector`), így a szerver-restart utáni in-memory index újraépül. A pool-t
-     * előbb üríti (idempotens hidratálás). A hiányos (üres `vectorId`/`embedding`) rekordokat átugorja.
-     * Visszaadja a betöltött vektorok számát. **NEM** Atlas — saját Mongo + in-memory pool.
-     */
-    hydrateFromMongo(): Promise<number>;
-    /**
-     * Perzistált rekordok közvetlen hidratálása a memória-pool-ba (Mongo-olvasás NÉLKÜL) — ha a hívó már
-     * 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[]): number;
-    /**
-     * Lazy persist-data-service (memory: dynts_dataservice_eager_resolve — a base-ctor eager
-     * `getDBService`-e miatt NEM tartható élő mezőként).
-     */
-    private getPersistService;
-}
+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 { LVS_VectorPool_ControlService } from './lvs-vector-pool.control-service';
+/**
+ * `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
+ * Vector Search.
+ *
+ * **Miért KOMPOZÍCIÓ (NEM a pool-class módosítása):** a `LVS_VectorPool_ControlService`-t egy másik,
+ * párhuzamos WIP (hybrid cosine+BM25) is érinti; a pool-class változtatása merge-konfliktust okozna.
+ * Ez a wrapper a pool-t VÁLTOZATLANUL hagyja (delegál: `addVector`/`removeVector`/`updateVector`/
+ * `search`), és a perzisztencia-mellékhatást a wrapper-metódusokban végzi. Egy wrapper-instance egy
+ * `collectionKey` (logikai pool); több pool = több wrapper.
+ *
+ * **FIGYELEM (memory: dynts_dataservice_eager_resolve):** a `DyNTS_DataService` base-ctor EAGER
+ * `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 declare 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;
+    /** A pool-particionálás kulcsa (a Mongo-rekordok `collectionKey`-e + a hidratálás-szűrő). */
+    private readonly collectionKey;
+    /** A perzisztencia-műveletek issuer-e (audit). */
+    private readonly issuer;
+    constructor(set: {
+        collectionKey: string;
+        issuer: string;
+        pool?: LVS_VectorPool_ControlService;
+    });
+    /** A wrapped in-memory pool (közvetlen olvasáshoz — pl. más search-mód, getAll). */
+    getPool(): LVS_VectorPool_ControlService;
+    /**
+     * Egy vektor felvétele a memória-pool-ba ÉS tartós upsert-je Mongo-ba (persist-on-write, FAM-minta).
+     * A pool `addVector`-ja upsert-szemantikájú (azonos kulcson felülír), a Mongo-oldal is `(collectionKey,
+     * vectorId)`-upsert. A Mongo-írás MELLÉKHATÁS a memória-művelet után (a memória a forrás, a Mongo a tár).
+     */
+    addVector(vectorId: string, vector: number[], metadata?: unknown): Promise<void>;
+    /**
+     * Egy MEGLÉVŐ vektor frissítése a memória-pool-ban + tartós upsert Mongo-ba. A pool `updateVector`-ja
+     * dob, ha a kulcs nem létezik (a pool-szerződés változatlan) — a Mongo-írás csak siker után fut.
+     */
+    updateVector(vectorId: string, vector: number[], metadata?: unknown): Promise<void>;
+    /** Egy vektor eltávolítása a memória-pool-ból ÉS a tartós tárból (`(collectionKey, vectorId)`). */
+    removeVector(vectorId: string): Promise<void>;
+    /** Keresés a memória-pool-on (a wrapped pool `search`-jét delegálja — VÁLTOZATLAN engine). */
+    search(query: number[], k: number, mode: LVS_Search_Mode): LVS_SearchResult[];
+    /**
+     * BOOT-HIDRATÁLÁS (FAM-minta, BFR-AM-001): a `collectionKey` ÖSSZES perzistált vektorát betölti a
+     * MEMÓRIA-pool-ba (`pool.addVector`), így a szerver-restart utáni in-memory index újraépül. A pool-t
+     * előbb üríti (idempotens hidratálás). A hiányos (üres `vectorId`/`embedding`) rekordokat átugorja.
+     * Visszaadja a betöltött vektorok számát. **NEM** Atlas — saját Mongo + in-memory pool.
+     */
+    hydrateFromMongo(): Promise<number>;
+    /**
+     * Perzistált rekordok közvetlen hidratálása a memória-pool-ba (Mongo-olvasás NÉLKÜL) — ha a hívó már
+     * 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[]): number;
+    /**
+     * Lazy persist-data-service (memory: dynts_dataservice_eager_resolve — a base-ctor eager
+     * `getDBService`-e miatt NEM tartható élő mezőként).
+     */
+    private getPersistService;
+}
 //# sourceMappingURL=lvs-persistent-vector-pool.control-service.d.ts.map

package/build/_modules/local-vector-search/_services/lvs-persistent-vector-pool.control-service.js

@@ -1,123 +1,123 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyNTS_LVS_PersistentVectorPool_ControlService = void 0;
-const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
-const lvs_vector_persist_data_service_1 = require("./lvs-vector-persist.data-service");
-const lvs_vector_pool_control_service_1 = require("./lvs-vector-pool.control-service");
-/**
- * `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
- * Vector Search.
- *
- * **Miért KOMPOZÍCIÓ (NEM a pool-class módosítása):** a `LVS_VectorPool_ControlService`-t egy másik,
- * párhuzamos WIP (hybrid cosine+BM25) is érinti; a pool-class változtatása merge-konfliktust okozna.
- * Ez a wrapper a pool-t VÁLTOZATLANUL hagyja (delegál: `addVector`/`removeVector`/`updateVector`/
- * `search`), és a perzisztencia-mellékhatást a wrapper-metódusokban végzi. Egy wrapper-instance egy
- * `collectionKey` (logikai pool); több pool = több wrapper.
- *
- * **FIGYELEM (memory: dynts_dataservice_eager_resolve):** a `DyNTS_DataService` base-ctor EAGER
- * `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).
- */
-class DyNTS_LVS_PersistentVectorPool_ControlService {
-    /** A wrapped in-memory pool (a Dynamo LVS engine; VÁLTOZATLAN — kompozíció, nem módosítás). */
-    pool;
-    /** A pool-particionálás kulcsa (a Mongo-rekordok `collectionKey`-e + a hidratálás-szűrő). */
-    collectionKey;
-    /** A perzisztencia-műveletek issuer-e (audit). */
-    issuer;
-    constructor(set) {
-        this.collectionKey = set.collectionKey;
-        this.issuer = set.issuer;
-        // Saját pool, ha a hívó nem ad be egyet (a wrapper nem módosítja a pool-osztályt — kompozíció).
-        this.pool = set.pool ?? new lvs_vector_pool_control_service_1.LVS_VectorPool_ControlService();
-    }
-    /** A wrapped in-memory pool (közvetlen olvasáshoz — pl. más search-mód, getAll). */
-    getPool() {
-        return this.pool;
-    }
-    /**
-     * Egy vektor felvétele a memória-pool-ba ÉS tartós upsert-je Mongo-ba (persist-on-write, FAM-minta).
-     * A pool `addVector`-ja upsert-szemantikájú (azonos kulcson felülír), a Mongo-oldal is `(collectionKey,
-     * vectorId)`-upsert. A Mongo-írás MELLÉKHATÁS a memória-művelet után (a memória a forrás, a Mongo a tár).
-     */
-    async addVector(vectorId, vector, metadata) {
-        this.pool.addVector(vectorId, vector);
-        await this.getPersistService().upsertVector({
-            collectionKey: this.collectionKey,
-            vectorId: vectorId,
-            embedding: vector,
-            metadata: metadata,
-        });
-    }
-    /**
-     * Egy MEGLÉVŐ vektor frissítése a memória-pool-ban + tartós upsert Mongo-ba. A pool `updateVector`-ja
-     * dob, ha a kulcs nem létezik (a pool-szerződés változatlan) — a Mongo-írás csak siker után fut.
-     */
-    async updateVector(vectorId, vector, metadata) {
-        this.pool.updateVector(vectorId, vector);
-        await this.getPersistService().upsertVector({
-            collectionKey: this.collectionKey,
-            vectorId: vectorId,
-            embedding: vector,
-            metadata: metadata,
-        });
-    }
-    /** Egy vektor eltávolítása a memória-pool-ból ÉS a tartós tárból (`(collectionKey, vectorId)`). */
-    async removeVector(vectorId) {
-        this.pool.removeVector(vectorId);
-        await this.getPersistService().removeVector(this.collectionKey, vectorId);
-    }
-    /** Keresés a memória-pool-on (a wrapped pool `search`-jét delegálja — VÁLTOZATLAN engine). */
-    search(query, k, mode) {
-        return this.pool.search(query, k, mode);
-    }
-    /**
-     * BOOT-HIDRATÁLÁS (FAM-minta, BFR-AM-001): a `collectionKey` ÖSSZES perzistált vektorát betölti a
-     * MEMÓRIA-pool-ba (`pool.addVector`), így a szerver-restart utáni in-memory index újraépül. A pool-t
-     * előbb üríti (idempotens hidratálás). A hiányos (üres `vectorId`/`embedding`) rekordokat átugorja.
-     * Visszaadja a betöltött vektorok számát. **NEM** Atlas — saját Mongo + in-memory pool.
-     */
-    async hydrateFromMongo() {
-        const records = await this.getPersistService().findByCollectionKey(this.collectionKey);
-        this.pool.clearPool();
-        let loaded = 0;
-        for (const record of records) {
-            if (!record.vectorId || !record.embedding?.length) {
-                continue;
-            }
-            this.pool.addVector(record.vectorId, record.embedding);
-            loaded++;
-        }
-        fsm_dynamo_1.DyFM_Log.log(`[DyNTS LVS hydrate] '${this.collectionKey}' pool: ${loaded} vektor betöltve az in-memory pool-ba.`);
-        return loaded;
-    }
-    /**
-     * Perzistált rekordok közvetlen hidratálása a memória-pool-ba (Mongo-olvasás NÉLKÜL) — ha a hívó már
-     * 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) {
-        this.pool.clearPool();
-        let loaded = 0;
-        for (const record of records) {
-            if (!record.vectorId || !record.embedding?.length) {
-                continue;
-            }
-            this.pool.addVector(record.vectorId, record.embedding);
-            loaded++;
-        }
-        return loaded;
-    }
-    /**
-     * Lazy persist-data-service (memory: dynts_dataservice_eager_resolve — a base-ctor eager
-     * `getDBService`-e miatt NEM tartható élő mezőként).
-     */
-    getPersistService() {
-        return new lvs_vector_persist_data_service_1.DyNTS_LVS_VectorPersist_DataService({ issuer: this.issuer });
-    }
-}
-exports.DyNTS_LVS_PersistentVectorPool_ControlService = DyNTS_LVS_PersistentVectorPool_ControlService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyNTS_LVS_PersistentVectorPool_ControlService = void 0;
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const lvs_vector_persist_data_service_1 = require("./lvs-vector-persist.data-service");
+const lvs_vector_pool_control_service_1 = require("./lvs-vector-pool.control-service");
+/**
+ * `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
+ * Vector Search.
+ *
+ * **Miért KOMPOZÍCIÓ (NEM a pool-class módosítása):** a `LVS_VectorPool_ControlService`-t egy másik,
+ * párhuzamos WIP (hybrid cosine+BM25) is érinti; a pool-class változtatása merge-konfliktust okozna.
+ * Ez a wrapper a pool-t VÁLTOZATLANUL hagyja (delegál: `addVector`/`removeVector`/`updateVector`/
+ * `search`), és a perzisztencia-mellékhatást a wrapper-metódusokban végzi. Egy wrapper-instance egy
+ * `collectionKey` (logikai pool); több pool = több wrapper.
+ *
+ * **FIGYELEM (memory: dynts_dataservice_eager_resolve):** a `DyNTS_DataService` base-ctor EAGER
+ * `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).
+ */
+class DyNTS_LVS_PersistentVectorPool_ControlService {
+    /** A wrapped in-memory pool (a Dynamo LVS engine; VÁLTOZATLAN — kompozíció, nem módosítás). */
+    pool;
+    /** A pool-particionálás kulcsa (a Mongo-rekordok `collectionKey`-e + a hidratálás-szűrő). */
+    collectionKey;
+    /** A perzisztencia-műveletek issuer-e (audit). */
+    issuer;
+    constructor(set) {
+        this.collectionKey = set.collectionKey;
+        this.issuer = set.issuer;
+        // Saját pool, ha a hívó nem ad be egyet (a wrapper nem módosítja a pool-osztályt — kompozíció).
+        this.pool = set.pool ?? new lvs_vector_pool_control_service_1.LVS_VectorPool_ControlService();
+    }
+    /** A wrapped in-memory pool (közvetlen olvasáshoz — pl. más search-mód, getAll). */
+    getPool() {
+        return this.pool;
+    }
+    /**
+     * Egy vektor felvétele a memória-pool-ba ÉS tartós upsert-je Mongo-ba (persist-on-write, FAM-minta).
+     * A pool `addVector`-ja upsert-szemantikájú (azonos kulcson felülír), a Mongo-oldal is `(collectionKey,
+     * vectorId)`-upsert. A Mongo-írás MELLÉKHATÁS a memória-művelet után (a memória a forrás, a Mongo a tár).
+     */
+    async addVector(vectorId, vector, metadata) {
+        this.pool.addVector(vectorId, vector);
+        await this.getPersistService().upsertVector({
+            collectionKey: this.collectionKey,
+            vectorId: vectorId,
+            embedding: vector,
+            metadata: metadata,
+        });
+    }
+    /**
+     * Egy MEGLÉVŐ vektor frissítése a memória-pool-ban + tartós upsert Mongo-ba. A pool `updateVector`-ja
+     * dob, ha a kulcs nem létezik (a pool-szerződés változatlan) — a Mongo-írás csak siker után fut.
+     */
+    async updateVector(vectorId, vector, metadata) {
+        this.pool.updateVector(vectorId, vector);
+        await this.getPersistService().upsertVector({
+            collectionKey: this.collectionKey,
+            vectorId: vectorId,
+            embedding: vector,
+            metadata: metadata,
+        });
+    }
+    /** Egy vektor eltávolítása a memória-pool-ból ÉS a tartós tárból (`(collectionKey, vectorId)`). */
+    async removeVector(vectorId) {
+        this.pool.removeVector(vectorId);
+        await this.getPersistService().removeVector(this.collectionKey, vectorId);
+    }
+    /** Keresés a memória-pool-on (a wrapped pool `search`-jét delegálja — VÁLTOZATLAN engine). */
+    search(query, k, mode) {
+        return this.pool.search(query, k, mode);
+    }
+    /**
+     * BOOT-HIDRATÁLÁS (FAM-minta, BFR-AM-001): a `collectionKey` ÖSSZES perzistált vektorát betölti a
+     * MEMÓRIA-pool-ba (`pool.addVector`), így a szerver-restart utáni in-memory index újraépül. A pool-t
+     * előbb üríti (idempotens hidratálás). A hiányos (üres `vectorId`/`embedding`) rekordokat átugorja.
+     * Visszaadja a betöltött vektorok számát. **NEM** Atlas — saját Mongo + in-memory pool.
+     */
+    async hydrateFromMongo() {
+        const records = await this.getPersistService().findByCollectionKey(this.collectionKey);
+        this.pool.clearPool();
+        let loaded = 0;
+        for (const record of records) {
+            if (!record.vectorId || !record.embedding?.length) {
+                continue;
+            }
+            this.pool.addVector(record.vectorId, record.embedding);
+            loaded++;
+        }
+        fsm_dynamo_1.DyFM_Log.log(`[DyNTS LVS hydrate] '${this.collectionKey}' pool: ${loaded} vektor betöltve az in-memory pool-ba.`);
+        return loaded;
+    }
+    /**
+     * Perzistált rekordok közvetlen hidratálása a memória-pool-ba (Mongo-olvasás NÉLKÜL) — ha a hívó már
+     * 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) {
+        this.pool.clearPool();
+        let loaded = 0;
+        for (const record of records) {
+            if (!record.vectorId || !record.embedding?.length) {
+                continue;
+            }
+            this.pool.addVector(record.vectorId, record.embedding);
+            loaded++;
+        }
+        return loaded;
+    }
+    /**
+     * Lazy persist-data-service (memory: dynts_dataservice_eager_resolve — a base-ctor eager
+     * `getDBService`-e miatt NEM tartható élő mezőként).
+     */
+    getPersistService() {
+        return new lvs_vector_persist_data_service_1.DyNTS_LVS_VectorPersist_DataService({ issuer: this.issuer });
+    }
+}
+exports.DyNTS_LVS_PersistentVectorPool_ControlService = DyNTS_LVS_PersistentVectorPool_ControlService;
 //# sourceMappingURL=lvs-persistent-vector-pool.control-service.js.map

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

@@ -1,43 +1,43 @@
-import { DyNTS_DataService } from '../../../_services/base/data.service';
-import { DyNTS_LVS_VectorPersist } from '../_models/data-models/lvs-vector-persist.data-model';
-/**
- * `DyNTS_LVS_VectorPersist_DataService` (BFR-AM-001) — a `dynts_lvs_vector` collection CRUD-rétege; a
- * `LVS_VectorPool_ControlService` in-memory pool-jának tartós Mongo-háttértára. `extends
- * DyNTS_DataService`; a nts-konvenció szerinti `{ data?, issuer }` constructor.
- *
- * **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_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 declare class DyNTS_LVS_VectorPersist_DataService extends DyNTS_DataService<DyNTS_LVS_VectorPersist> {
-    constructor(set: {
-        data?: DyNTS_LVS_VectorPersist;
-        issuer: string;
-    });
-    /**
-     * Egy (logikai) pool ÖSSZES perzistált, nem-soft-delete-elt vektor-rekordja — a boot-hidratáláshoz
-     * (a `DyNTS_LVS_PersistentVectorPool_ControlService.hydrateFromMongo` ezt tölti az in-memory pool-ba).
-     */
-    findByCollectionKey(collectionKey: string): Promise<DyNTS_LVS_VectorPersist[]>;
-    /**
-     * Egy vektor ATOMIKUS upsert-je a `(collectionKey, vectorId)` logikai-kulcson. MEGLÉVŐ rekordnál
-     * `$set` (a Mixed `metadata` silent-drop ellen — memory: mongoose_mixed_atomic_write); ÚJ rekordnál
-     * `saveData`. A dimenzió az `embedding.length`-ből rögzül.
-     */
-    upsertVector(set: {
-        collectionKey: string;
-        vectorId: string;
-        embedding: number[];
-        metadata?: unknown;
-    }): Promise<void>;
-    /**
-     * Egy vektor-rekord végleges törlése a `(collectionKey, vectorId)` logikai-kulcson (a pool
-     * `removeVector`-ja után — a tartós tár is törli). `addArchive` nincs → `absolute` true-val töröl.
-     */
-    removeVector(collectionKey: string, vectorId: string): Promise<void>;
-}
+import { DyNTS_DataService } from '../../../_services/base/data.service';
+import { DyNTS_LVS_VectorPersist } from '../_models/data-models/lvs-vector-persist.data-model';
+/**
+ * `DyNTS_LVS_VectorPersist_DataService` (BFR-AM-001) — a `dynts_lvs_vector` collection CRUD-rétege; a
+ * `LVS_VectorPool_ControlService` in-memory pool-jának tartós Mongo-háttértára. `extends
+ * DyNTS_DataService`; a nts-konvenció szerinti `{ data?, issuer }` constructor.
+ *
+ * **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_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 declare class DyNTS_LVS_VectorPersist_DataService extends DyNTS_DataService<DyNTS_LVS_VectorPersist> {
+    constructor(set: {
+        data?: DyNTS_LVS_VectorPersist;
+        issuer: string;
+    });
+    /**
+     * Egy (logikai) pool ÖSSZES perzistált, nem-soft-delete-elt vektor-rekordja — a boot-hidratáláshoz
+     * (a `DyNTS_LVS_PersistentVectorPool_ControlService.hydrateFromMongo` ezt tölti az in-memory pool-ba).
+     */
+    findByCollectionKey(collectionKey: string): Promise<DyNTS_LVS_VectorPersist[]>;
+    /**
+     * Egy vektor ATOMIKUS upsert-je a `(collectionKey, vectorId)` logikai-kulcson. MEGLÉVŐ rekordnál
+     * `$set` (a Mixed `metadata` silent-drop ellen — memory: mongoose_mixed_atomic_write); ÚJ rekordnál
+     * `saveData`. A dimenzió az `embedding.length`-ből rögzül.
+     */
+    upsertVector(set: {
+        collectionKey: string;
+        vectorId: string;
+        embedding: number[];
+        metadata?: unknown;
+    }): Promise<void>;
+    /**
+     * Egy vektor-rekord végleges törlése a `(collectionKey, vectorId)` logikai-kulcson (a pool
+     * `removeVector`-ja után — a tartós tár is törli). `addArchive` nincs → `absolute` true-val töröl.
+     */
+    removeVector(collectionKey: string, vectorId: string): Promise<void>;
+}
 //# sourceMappingURL=lvs-vector-persist.data-service.d.ts.map

package/build/_modules/local-vector-search/_services/lvs-vector-persist.data-service.js

@@ -1,72 +1,72 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyNTS_LVS_VectorPersist_DataService = void 0;
-const data_service_1 = require("../../../_services/base/data.service");
-const lvs_vector_persist_data_model_1 = require("../_models/data-models/lvs-vector-persist.data-model");
-/**
- * `DyNTS_LVS_VectorPersist_DataService` (BFR-AM-001) — a `dynts_lvs_vector` collection CRUD-rétege; a
- * `LVS_VectorPool_ControlService` in-memory pool-jának tartós Mongo-háttértára. `extends
- * DyNTS_DataService`; a nts-konvenció szerinti `{ data?, issuer }` constructor.
- *
- * **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_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.
- */
-class DyNTS_LVS_VectorPersist_DataService extends data_service_1.DyNTS_DataService {
-    constructor(set) {
-        super(set.data instanceof lvs_vector_persist_data_model_1.DyNTS_LVS_VectorPersist
-            ? set.data
-            : new lvs_vector_persist_data_model_1.DyNTS_LVS_VectorPersist(set.data), lvs_vector_persist_data_model_1.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_ControlService.hydrateFromMongo` ezt tölti az in-memory pool-ba).
-     */
-    async findByCollectionKey(collectionKey) {
-        return this.findDataList({ collectionKey: collectionKey }, true);
-    }
-    /**
-     * Egy vektor ATOMIKUS upsert-je a `(collectionKey, vectorId)` logikai-kulcson. MEGLÉVŐ rekordnál
-     * `$set` (a Mixed `metadata` silent-drop ellen — memory: mongoose_mixed_atomic_write); ÚJ rekordnál
-     * `saveData`. A dimenzió az `embedding.length`-ből rögzül.
-     */
-    async upsertVector(set) {
-        const existing = await this.findData({ collectionKey: set.collectionKey, vectorId: set.vectorId }, true);
-        if (existing?._id) {
-            await this.updateData({
-                filterBy: { _id: existing._id },
-                update: {
-                    $set: {
-                        embedding: set.embedding,
-                        dimensions: set.embedding.length,
-                        metadata: set.metadata,
-                    },
-                },
-            });
-            return;
-        }
-        await this.saveData(new lvs_vector_persist_data_model_1.DyNTS_LVS_VectorPersist({
-            collectionKey: set.collectionKey,
-            vectorId: set.vectorId,
-            embedding: set.embedding,
-            dimensions: set.embedding.length,
-            metadata: set.metadata,
-        }), true);
-    }
-    /**
-     * Egy vektor-rekord végleges törlése a `(collectionKey, vectorId)` logikai-kulcson (a pool
-     * `removeVector`-ja után — a tartós tár is törli). `addArchive` nincs → `absolute` true-val töröl.
-     */
-    async removeVector(collectionKey, vectorId) {
-        const existing = await this.findData({ collectionKey: collectionKey, vectorId: vectorId }, true);
-        if (existing?._id) {
-            await this.deleteData(existing._id, true);
-        }
-    }
-}
-exports.DyNTS_LVS_VectorPersist_DataService = DyNTS_LVS_VectorPersist_DataService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyNTS_LVS_VectorPersist_DataService = void 0;
+const data_service_1 = require("../../../_services/base/data.service");
+const lvs_vector_persist_data_model_1 = require("../_models/data-models/lvs-vector-persist.data-model");
+/**
+ * `DyNTS_LVS_VectorPersist_DataService` (BFR-AM-001) — a `dynts_lvs_vector` collection CRUD-rétege; a
+ * `LVS_VectorPool_ControlService` in-memory pool-jának tartós Mongo-háttértára. `extends
+ * DyNTS_DataService`; a nts-konvenció szerinti `{ data?, issuer }` constructor.
+ *
+ * **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_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.
+ */
+class DyNTS_LVS_VectorPersist_DataService extends data_service_1.DyNTS_DataService {
+    constructor(set) {
+        super(set.data instanceof lvs_vector_persist_data_model_1.DyNTS_LVS_VectorPersist
+            ? set.data
+            : new lvs_vector_persist_data_model_1.DyNTS_LVS_VectorPersist(set.data), lvs_vector_persist_data_model_1.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_ControlService.hydrateFromMongo` ezt tölti az in-memory pool-ba).
+     */
+    async findByCollectionKey(collectionKey) {
+        return this.findDataList({ collectionKey: collectionKey }, true);
+    }
+    /**
+     * Egy vektor ATOMIKUS upsert-je a `(collectionKey, vectorId)` logikai-kulcson. MEGLÉVŐ rekordnál
+     * `$set` (a Mixed `metadata` silent-drop ellen — memory: mongoose_mixed_atomic_write); ÚJ rekordnál
+     * `saveData`. A dimenzió az `embedding.length`-ből rögzül.
+     */
+    async upsertVector(set) {
+        const existing = await this.findData({ collectionKey: set.collectionKey, vectorId: set.vectorId }, true);
+        if (existing?._id) {
+            await this.updateData({
+                filterBy: { _id: existing._id },
+                update: {
+                    $set: {
+                        embedding: set.embedding,
+                        dimensions: set.embedding.length,
+                        metadata: set.metadata,
+                    },
+                },
+            });
+            return;
+        }
+        await this.saveData(new lvs_vector_persist_data_model_1.DyNTS_LVS_VectorPersist({
+            collectionKey: set.collectionKey,
+            vectorId: set.vectorId,
+            embedding: set.embedding,
+            dimensions: set.embedding.length,
+            metadata: set.metadata,
+        }), true);
+    }
+    /**
+     * Egy vektor-rekord végleges törlése a `(collectionKey, vectorId)` logikai-kulcson (a pool
+     * `removeVector`-ja után — a tartós tár is törli). `addArchive` nincs → `absolute` true-val töröl.
+     */
+    async removeVector(collectionKey, vectorId) {
+        const existing = await this.findData({ collectionKey: collectionKey, vectorId: vectorId }, true);
+        if (existing?._id) {
+            await this.deleteData(existing._id, true);
+        }
+    }
+}
+exports.DyNTS_LVS_VectorPersist_DataService = DyNTS_LVS_VectorPersist_DataService;
 //# sourceMappingURL=lvs-vector-persist.data-service.js.map