@futdevpro/nts-dynamo 1.15.155 → 1.15.156

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

@@ -1,84 +1,84 @@
-"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);
-    }
-    /**
-     * BFR-AM-013 (hydration-paging): LEAN + projektált (CSAK `vectorId` + `embedding` — a content-szöveg
-     * és metadata NÉLKÜL) cursor-batch scan a boot-hidratáláshoz. A heap-tranziens felső korlátja EGY batch
-     * (a teljes result-set + Mongoose-doc-boxing kimarad). Soft-delete-elt rekordok kihagyva.
-     */
-    async findLeanBatchedByCollectionKey(collectionKey, set) {
-        return this.dataDBService.findLeanBatched({ collectionKey: collectionKey, _deleted: undefined }, {
-            projection: { vectorId: 1, embedding: 1 },
-            batchSize: set.batchSize,
-            handler: set.handler,
-        });
-    }
-    /**
-     * 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);
+    }
+    /**
+     * BFR-AM-013 (hydration-paging): LEAN + projektált (CSAK `vectorId` + `embedding` — a content-szöveg
+     * és metadata NÉLKÜL) cursor-batch scan a boot-hidratáláshoz. A heap-tranziens felső korlátja EGY batch
+     * (a teljes result-set + Mongoose-doc-boxing kimarad). Soft-delete-elt rekordok kihagyva.
+     */
+    async findLeanBatchedByCollectionKey(collectionKey, set) {
+        return this.dataDBService.findLeanBatched({ collectionKey: collectionKey, _deleted: undefined }, {
+            projection: { vectorId: 1, embedding: 1 },
+            batchSize: set.batchSize,
+            handler: set.handler,
+        });
+    }
+    /**
+     * 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

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

@@ -1,100 +1,100 @@
-import { LVS_Search_Mode } from '../_enums/lvs-search-mode.enum';
-import { LVS_SearchResult } from '../_models/lvs-search-result.interface';
-/**
- * Vektor pool kezelő utility class
- * Instance-based class, amely in-memory vektor pool-t kezel és vektor hasonlósági számításokat végez
- * Minden instance saját vektor pool-t tart fenn
- */
-export declare class LVS_VectorPool_ControlService {
-    /**
-     * In-memory vektor pool tárolás
-     * Key: vektor ID, Value: vektor értékek
-     *
-     * BFR-AM-013 (Tier-1 memória): a belső tárolás `Float32Array` (4 byte/elem, boxing nélkül) a
-     * korábbi `number[]` (8 byte + array-boxing) helyett → ~2–4× kisebb PERSISTENS pool-footprint
-     * (2560-dim × 32k vektornál a heap érdemi része). A cosine/l2 index-alapú loopjai változatlanul
-     * futnak rajta; a publikus `getAll()` kontraktja (number[]) konverzióval megőrzött.
-     */
-    private vectorPool;
-    /**
-     * Normalizált vektor pool tárolás (L2 normalizált másolatok)
-     * Key: vektor ID, Value: L2 normalizált vektor értékek (Float32Array — l. fent)
-     */
-    private normalizedVectorPool;
-    /**
-     * `normalizedOnly` mód: ha `true`, a pool NEM tárolja a nyers vektorokat (`vectorPool`) — CSAK a
-     * normalizált másolatot. A kizárólag-cosine fogyasztóknak (pl. RAG-keresés) ez ~50% memória-megtakarítás
-     * (a két párhuzamos pool helyett egy). Ekkor az `l2Distance`-keresés és a `getAll()` nyers-érték-olvasása
-     * N/A (a `size()` + a `cosineSimilarity`-keresés továbbra is helyes). Default `false` (visszafelé kompatibilis).
-     */
-    private readonly normalizedOnly;
-    constructor(set?: {
-        normalizedOnly?: boolean;
-    });
-    /**
-     * Hozzáad egy vektort a pool-hoz
-     * Opcionálisan L2 normalizált másolatot is tárol
-     */
-    addVector(id: string, vector: number[]): void;
-    /**
-     * Eltávolít egy vektort a pool-ból
-     */
-    removeVector(id: string): void;
-    /**
-     * Frissít egy vektort a pool-ban
-     */
-    updateVector(id: string, vector: number[]): void;
-    /**
-     * A pool elemszáma. Mindkét módban helyes (a `normalizedVectorPool` a forrás), így `normalizedOnly`
-     * módban is — szemben a `getAll().size`-szal, ami ott üres (a nyers pool nincs tárolva).
-     */
-    size(): number;
-    /**
-     * Törli az összes vektort a pool-ból
-     */
-    clearPool(): void;
-    /**
-     * Visszaadja az összes vektort a pool-ból
-     * Debugging és export céljára
-     */
-    getAll(): Map<string, number[]>;
-    /**
-     * BFR-AM-013 (Tier-1): L2-normalizálás Float32Array-be, explicit loopokkal (allokáció-minimális) —
-     * a pool BELSŐ tárolási formátumához. Nullvektor → csupa-0 Float32Array.
-     */
-    private static l2NormalizeFloat32;
-    /**
-     * L2 normalizálás egy vektorra
-     * A vektor hosszát 1-re normalizálja
-     * Statikus metódus, mivel nincs szüksége instance state-re
-     */
-    private static l2Normalize;
-    /**
-     * Cosine similarity számítás két vektor között
-     * Normalizált vektorokat használ a számításhoz
-     * Eredmény: 0 és 1 közötti érték, ahol 1 a legnagyobb hasonlóság
-     * Statikus metódus, mivel nincs szüksége instance state-re
-     */
-    static cosineSimilarity(a: number[], b: number[]): number;
-    /**
-     * L2 distance (Euklideszi távolság) számítás két vektor között
-     * Eredmény: 0 vagy pozitív érték, ahol 0 a legkisebb távolság
-     * Statikus metódus, mivel nincs szüksége instance state-re
-     */
-    static l2Distance(a: ArrayLike<number>, b: ArrayLike<number>): number;
-    /**
-     * Vektor keresés a pool-ban
-     * Brute-force megközelítés (lineáris keresés)
-     *
-     * @param query A keresési query vektor
-     * @param k A visszaadandó találatok száma (top-K)
-     * @param mode A keresési mód (cosine similarity vagy L2 distance)
-     * @param candidateIds Opcionális jelölt-ID szűrő: ha meg van adva, a keresés CSAK az ebben a
-     *   halmazban lévő ID-kra fut (a többit `Set.has` O(1)-gyel kihagyja). Így a hívónak NEM kell külön
-     *   szűkített pool-t építenie + a vektorokat újra-normalizálnia — a keresés a MÁR előre-normalizált
-     *   `normalizedVectorPool`-on iterál allokáció-mentesen. Üres halmaz → üres eredmény.
-     * @returns A top-K találatok ID-val és score-rel, megfelelő sorrendben
-     */
-    search(query: number[], k: number, mode: LVS_Search_Mode, candidateIds?: Set<string>): LVS_SearchResult[];
-}
+import { LVS_Search_Mode } from '../_enums/lvs-search-mode.enum';
+import { LVS_SearchResult } from '../_models/lvs-search-result.interface';
+/**
+ * Vektor pool kezelő utility class
+ * Instance-based class, amely in-memory vektor pool-t kezel és vektor hasonlósági számításokat végez
+ * Minden instance saját vektor pool-t tart fenn
+ */
+export declare class LVS_VectorPool_ControlService {
+    /**
+     * In-memory vektor pool tárolás
+     * Key: vektor ID, Value: vektor értékek
+     *
+     * BFR-AM-013 (Tier-1 memória): a belső tárolás `Float32Array` (4 byte/elem, boxing nélkül) a
+     * korábbi `number[]` (8 byte + array-boxing) helyett → ~2–4× kisebb PERSISTENS pool-footprint
+     * (2560-dim × 32k vektornál a heap érdemi része). A cosine/l2 index-alapú loopjai változatlanul
+     * futnak rajta; a publikus `getAll()` kontraktja (number[]) konverzióval megőrzött.
+     */
+    private vectorPool;
+    /**
+     * Normalizált vektor pool tárolás (L2 normalizált másolatok)
+     * Key: vektor ID, Value: L2 normalizált vektor értékek (Float32Array — l. fent)
+     */
+    private normalizedVectorPool;
+    /**
+     * `normalizedOnly` mód: ha `true`, a pool NEM tárolja a nyers vektorokat (`vectorPool`) — CSAK a
+     * normalizált másolatot. A kizárólag-cosine fogyasztóknak (pl. RAG-keresés) ez ~50% memória-megtakarítás
+     * (a két párhuzamos pool helyett egy). Ekkor az `l2Distance`-keresés és a `getAll()` nyers-érték-olvasása
+     * N/A (a `size()` + a `cosineSimilarity`-keresés továbbra is helyes). Default `false` (visszafelé kompatibilis).
+     */
+    private readonly normalizedOnly;
+    constructor(set?: {
+        normalizedOnly?: boolean;
+    });
+    /**
+     * Hozzáad egy vektort a pool-hoz
+     * Opcionálisan L2 normalizált másolatot is tárol
+     */
+    addVector(id: string, vector: number[]): void;
+    /**
+     * Eltávolít egy vektort a pool-ból
+     */
+    removeVector(id: string): void;
+    /**
+     * Frissít egy vektort a pool-ban
+     */
+    updateVector(id: string, vector: number[]): void;
+    /**
+     * A pool elemszáma. Mindkét módban helyes (a `normalizedVectorPool` a forrás), így `normalizedOnly`
+     * módban is — szemben a `getAll().size`-szal, ami ott üres (a nyers pool nincs tárolva).
+     */
+    size(): number;
+    /**
+     * Törli az összes vektort a pool-ból
+     */
+    clearPool(): void;
+    /**
+     * Visszaadja az összes vektort a pool-ból
+     * Debugging és export céljára
+     */
+    getAll(): Map<string, number[]>;
+    /**
+     * BFR-AM-013 (Tier-1): L2-normalizálás Float32Array-be, explicit loopokkal (allokáció-minimális) —
+     * a pool BELSŐ tárolási formátumához. Nullvektor → csupa-0 Float32Array.
+     */
+    private static l2NormalizeFloat32;
+    /**
+     * L2 normalizálás egy vektorra
+     * A vektor hosszát 1-re normalizálja
+     * Statikus metódus, mivel nincs szüksége instance state-re
+     */
+    private static l2Normalize;
+    /**
+     * Cosine similarity számítás két vektor között
+     * Normalizált vektorokat használ a számításhoz
+     * Eredmény: 0 és 1 közötti érték, ahol 1 a legnagyobb hasonlóság
+     * Statikus metódus, mivel nincs szüksége instance state-re
+     */
+    static cosineSimilarity(a: number[], b: number[]): number;
+    /**
+     * L2 distance (Euklideszi távolság) számítás két vektor között
+     * Eredmény: 0 vagy pozitív érték, ahol 0 a legkisebb távolság
+     * Statikus metódus, mivel nincs szüksége instance state-re
+     */
+    static l2Distance(a: ArrayLike<number>, b: ArrayLike<number>): number;
+    /**
+     * Vektor keresés a pool-ban
+     * Brute-force megközelítés (lineáris keresés)
+     *
+     * @param query A keresési query vektor
+     * @param k A visszaadandó találatok száma (top-K)
+     * @param mode A keresési mód (cosine similarity vagy L2 distance)
+     * @param candidateIds Opcionális jelölt-ID szűrő: ha meg van adva, a keresés CSAK az ebben a
+     *   halmazban lévő ID-kra fut (a többit `Set.has` O(1)-gyel kihagyja). Így a hívónak NEM kell külön
+     *   szűkített pool-t építenie + a vektorokat újra-normalizálnia — a keresés a MÁR előre-normalizált
+     *   `normalizedVectorPool`-on iterál allokáció-mentesen. Üres halmaz → üres eredmény.
+     * @returns A top-K találatok ID-val és score-rel, megfelelő sorrendben
+     */
+    search(query: number[], k: number, mode: LVS_Search_Mode, candidateIds?: Set<string>): LVS_SearchResult[];
+}
 //# sourceMappingURL=lvs-vector-pool.control-service.d.ts.map