@futdevpro/nts-dynamo 1.15.74 → 1.15.75

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

@@ -1,272 +1,272 @@
-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 class LVS_VectorPool_ControlService {
-  /**
-   * In-memory vektor pool tárolás
-   * Key: vektor ID, Value: vektor értékek
-   */
-  private vectorPool: Map<string, number[]> = new Map<string, number[]>();
-
-  /**
-   * Normalizált vektor pool tárolás (L2 normalizált másolatok)
-   * Key: vektor ID, Value: L2 normalizált vektor értékek
-   */
-  private normalizedVectorPool: Map<string, number[]> = new Map<string, number[]>();
-
-  /**
-   * `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: boolean;
-
-  constructor(set?: { normalizedOnly?: boolean }) {
-    this.normalizedOnly = set?.normalizedOnly ?? false;
-  }
-
-  /**
-   * Hozzáad egy vektort a pool-hoz
-   * Opcionálisan L2 normalizált másolatot is tárol
-   */
-  addVector(id: string, vector: number[]): void {
-    if (!id) {
-      throw new Error('Vector ID is required');
-    }
-
-    if (!Array.isArray(vector) || vector.length === 0) {
-      throw new Error('Vector must be a non-empty array');
-    }
-
-    // Validáljuk, hogy a vektor számokból áll
-    for (let i: number = 0; i < vector.length; i++) {
-      if (typeof vector[i] !== 'number' || !isFinite(vector[i])) {
-        throw new Error(`Vector must contain only finite numbers at index ${i}`);
-      }
-    }
-
-    // Tároljuk az eredeti vektort — KIVÉVE normalizedOnly módban (akkor a nyers pool kihagyva, ~50% memória).
-    if (!this.normalizedOnly) {
-      this.vectorPool.set(id, vector);
-    }
-
-    // L2 normalizált másolatot is tárolunk a cosine similarity számításokhoz
-    const normalized: number[] = LVS_VectorPool_ControlService.l2Normalize(vector);
-    this.normalizedVectorPool.set(id, normalized);
-  }
-
-  /**
-   * Eltávolít egy vektort a pool-ból
-   */
-  removeVector(id: string): void {
-    this.vectorPool.delete(id);
-    this.normalizedVectorPool.delete(id);
-  }
-
-  /**
-   * Frissít egy vektort a pool-ban
-   */
-  updateVector(id: string, vector: number[]): void {
-    // A `normalizedVectorPool` a forrás (mindkét módban populált; `normalizedOnly`-ban a `vectorPool` üres).
-    if (!this.normalizedVectorPool.has(id)) {
-      throw new Error(`Vector with ID "${id}" does not exist`);
-    }
-
-    this.addVector(id, vector);
-  }
-
-  /**
-   * 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 {
-    return this.normalizedVectorPool.size;
-  }
-
-  /**
-   * Törli az összes vektort a pool-ból
-   */
-  clearPool(): void {
-    this.vectorPool.clear();
-    this.normalizedVectorPool.clear();
-  }
-
-  /**
-   * Visszaadja az összes vektort a pool-ból
-   * Debugging és export céljára
-   */
-  getAll(): Map<string, number[]> {
-    return new Map<string, number[]>(this.vectorPool);
-  }
-
-  /**
-   * 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(vector: number[]): number[] {
-    const magnitude: number = Math.sqrt(
-      vector.reduce((sum: number, value: number) => sum + value * value, 0)
-    );
-
-    if (magnitude === 0) {
-      // Ha a vektor nullvektor, akkor nullvektort adunk vissza
-      return new Array<number>(vector.length).fill(0);
-    }
-
-    return vector.map((value: number) => value / magnitude);
-  }
-
-  /**
-   * 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 {
-    if (a.length !== b.length) {
-      throw new Error(
-        `Vectors must have the same dimension. Got ${a.length} and ${b.length}`
-      );
-    }
-
-    // Normalizáljuk a vektorokat
-    const normalizedA: number[] = this.l2Normalize(a);
-    const normalizedB: number[] = this.l2Normalize(b);
-
-    // Dot product számítása
-    let dotProduct: number = 0;
-    for (let i: number = 0; i < normalizedA.length; i++) {
-      dotProduct += normalizedA[i] * normalizedB[i];
-    }
-
-    // Cosine similarity = dot product of normalized vectors
-    // Mivel a vektorok normalizáltak, ez egyenlő a cosine similarity-vel
-    return dotProduct;
-  }
-
-  /**
-   * 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: number[], b: number[]): number {
-    if (a.length !== b.length) {
-      throw new Error(
-        `Vectors must have the same dimension. Got ${a.length} and ${b.length}`
-      );
-    }
-
-    // L2 distance = sqrt(sum((a[i] - b[i])^2))
-    let sumSquaredDiff: number = 0;
-    for (let i: number = 0; i < a.length; i++) {
-      const diff: number = a[i] - b[i];
-      sumSquaredDiff += diff * diff;
-    }
-
-    return Math.sqrt(sumSquaredDiff);
-  }
-
-  /**
-   * 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[] {
-    // Üres jelölt-halmaz → nincs mit keresni (a `undefined` viszont „nincs szűrés" = teljes pool).
-    if (candidateIds && candidateIds.size === 0) {
-      return [];
-    }
-    if (!Array.isArray(query) || query.length === 0) {
-      throw new Error('Query vector must be a non-empty array');
-    }
-
-    if (k <= 0) {
-      throw new Error('k must be a positive number');
-    }
-
-    // `normalizedOnly` módban nincs nyers pool → l2Distance nem számolható (csak cosine).
-    if (this.normalizedOnly && mode === LVS_Search_Mode.l2Distance) {
-      throw new Error('l2Distance search is not available in normalizedOnly mode (raw vectors are not stored)');
-    }
-
-    // Üres pool → üres eredmény. A `normalizedVectorPool` a forrás (mindkét módban populált; a nyers
-    // `vectorPool` `normalizedOnly`-ban üres, ezért NEM azon ellenőrzünk).
-    if (this.normalizedVectorPool.size === 0) {
-      return [];
-    }
-
-    // Validáljuk, hogy minden vektor ugyanolyan dimenziójú-e. A referencia-pool mód-függő: l2 a nyers,
-    // cosine a normalizált (azonos dimenzió, de `normalizedOnly`-ban a nyers pool üres).
-    const referencePool: Map<string, number[]> =
-      mode === LVS_Search_Mode.l2Distance ? this.vectorPool : this.normalizedVectorPool;
-    const firstVector: number[] | undefined = Array.from(referencePool.values())[0];
-    if (firstVector && firstVector.length !== query.length) {
-      throw new Error(
-        `Query vector dimension (${query.length}) does not match pool vector ` +
-        `dimension (${firstVector.length})`
-      );
-    }
-
-    // Számoljuk ki a hasonlóságot/távolságot minden vektorra
-    const results: LVS_SearchResult[] = [];
-
-    if (mode === LVS_Search_Mode.cosineSimilarity) {
-      // PERF (BFR-AM-013): a query-t EGYSZER normalizáljuk, majd dot-product a MÁR ELŐRE eltárolt
-      // `normalizedVectorPool` (l2-normalizált) vektorok ellen. Eredmény AZONOS a régi
-      // `cosineSimilarity(query, vector)`-ral (= dot(norm(q), norm(v))), de:
-      //  (1) NEM normalizáljuk újra MINDEN vektort MINDEN keresésnél (a normalizálás a `addVector`-ban
-      //      egyszer megtörtént) → ~3× kevesebb FLOP;
-      //  (2) a per-összehasonlítás dot-product ALLOKÁCIÓ-MENTES (a régi `l2Normalize` hívásonként KÉT új
-      //      tömböt allokált → egy 24k-vektoros keresés ~48k tömb-allokáció + GC-spike-ot okozott).
-      // A drágán eltárolt `normalizedVectorPool` korábban SOHA nem volt használva a keresésben.
-      const queryNormalized: number[] = LVS_VectorPool_ControlService.l2Normalize(query);
-      for (const [id, normalizedVector] of this.normalizedVectorPool.entries()) {
-        if (candidateIds && !candidateIds.has(id)) {
-          continue;
-        }
-        let dotProduct: number = 0;
-        for (let i: number = 0; i < queryNormalized.length; i++) {
-          dotProduct += queryNormalized[i] * normalizedVector[i];
-        }
-        results.push({ id, score: dotProduct });
-      }
-      // Cosine similarity: csökkenő sorrend (legnagyobb hasonlóság először)
-      results.sort((a: LVS_SearchResult, b: LVS_SearchResult) => b.score - a.score);
-    } else if (mode === LVS_Search_Mode.l2Distance) {
-      for (const [id, vector] of this.vectorPool.entries()) {
-        if (candidateIds && !candidateIds.has(id)) {
-          continue;
-        }
-        results.push({ id, score: LVS_VectorPool_ControlService.l2Distance(query, vector) });
-      }
-      // L2 distance: növekvő sorrend (legkisebb távolság először)
-      results.sort((a: LVS_SearchResult, b: LVS_SearchResult) => a.score - b.score);
-    } else {
-      throw new Error(`Unknown search mode: ${mode}`);
-    }
-
-    // Visszaadjuk a top-K találatot
-    return results.slice(0, k);
-  }
-}
-
+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 class LVS_VectorPool_ControlService {
+  /**
+   * In-memory vektor pool tárolás
+   * Key: vektor ID, Value: vektor értékek
+   */
+  private vectorPool: Map<string, number[]> = new Map<string, number[]>();
+
+  /**
+   * Normalizált vektor pool tárolás (L2 normalizált másolatok)
+   * Key: vektor ID, Value: L2 normalizált vektor értékek
+   */
+  private normalizedVectorPool: Map<string, number[]> = new Map<string, number[]>();
+
+  /**
+   * `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: boolean;
+
+  constructor(set?: { normalizedOnly?: boolean }) {
+    this.normalizedOnly = set?.normalizedOnly ?? false;
+  }
+
+  /**
+   * Hozzáad egy vektort a pool-hoz
+   * Opcionálisan L2 normalizált másolatot is tárol
+   */
+  addVector(id: string, vector: number[]): void {
+    if (!id) {
+      throw new Error('Vector ID is required');
+    }
+
+    if (!Array.isArray(vector) || vector.length === 0) {
+      throw new Error('Vector must be a non-empty array');
+    }
+
+    // Validáljuk, hogy a vektor számokból áll
+    for (let i: number = 0; i < vector.length; i++) {
+      if (typeof vector[i] !== 'number' || !isFinite(vector[i])) {
+        throw new Error(`Vector must contain only finite numbers at index ${i}`);
+      }
+    }
+
+    // Tároljuk az eredeti vektort — KIVÉVE normalizedOnly módban (akkor a nyers pool kihagyva, ~50% memória).
+    if (!this.normalizedOnly) {
+      this.vectorPool.set(id, vector);
+    }
+
+    // L2 normalizált másolatot is tárolunk a cosine similarity számításokhoz
+    const normalized: number[] = LVS_VectorPool_ControlService.l2Normalize(vector);
+    this.normalizedVectorPool.set(id, normalized);
+  }
+
+  /**
+   * Eltávolít egy vektort a pool-ból
+   */
+  removeVector(id: string): void {
+    this.vectorPool.delete(id);
+    this.normalizedVectorPool.delete(id);
+  }
+
+  /**
+   * Frissít egy vektort a pool-ban
+   */
+  updateVector(id: string, vector: number[]): void {
+    // A `normalizedVectorPool` a forrás (mindkét módban populált; `normalizedOnly`-ban a `vectorPool` üres).
+    if (!this.normalizedVectorPool.has(id)) {
+      throw new Error(`Vector with ID "${id}" does not exist`);
+    }
+
+    this.addVector(id, vector);
+  }
+
+  /**
+   * 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 {
+    return this.normalizedVectorPool.size;
+  }
+
+  /**
+   * Törli az összes vektort a pool-ból
+   */
+  clearPool(): void {
+    this.vectorPool.clear();
+    this.normalizedVectorPool.clear();
+  }
+
+  /**
+   * Visszaadja az összes vektort a pool-ból
+   * Debugging és export céljára
+   */
+  getAll(): Map<string, number[]> {
+    return new Map<string, number[]>(this.vectorPool);
+  }
+
+  /**
+   * 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(vector: number[]): number[] {
+    const magnitude: number = Math.sqrt(
+      vector.reduce((sum: number, value: number) => sum + value * value, 0)
+    );
+
+    if (magnitude === 0) {
+      // Ha a vektor nullvektor, akkor nullvektort adunk vissza
+      return new Array<number>(vector.length).fill(0);
+    }
+
+    return vector.map((value: number) => value / magnitude);
+  }
+
+  /**
+   * 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 {
+    if (a.length !== b.length) {
+      throw new Error(
+        `Vectors must have the same dimension. Got ${a.length} and ${b.length}`
+      );
+    }
+
+    // Normalizáljuk a vektorokat
+    const normalizedA: number[] = this.l2Normalize(a);
+    const normalizedB: number[] = this.l2Normalize(b);
+
+    // Dot product számítása
+    let dotProduct: number = 0;
+    for (let i: number = 0; i < normalizedA.length; i++) {
+      dotProduct += normalizedA[i] * normalizedB[i];
+    }
+
+    // Cosine similarity = dot product of normalized vectors
+    // Mivel a vektorok normalizáltak, ez egyenlő a cosine similarity-vel
+    return dotProduct;
+  }
+
+  /**
+   * 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: number[], b: number[]): number {
+    if (a.length !== b.length) {
+      throw new Error(
+        `Vectors must have the same dimension. Got ${a.length} and ${b.length}`
+      );
+    }
+
+    // L2 distance = sqrt(sum((a[i] - b[i])^2))
+    let sumSquaredDiff: number = 0;
+    for (let i: number = 0; i < a.length; i++) {
+      const diff: number = a[i] - b[i];
+      sumSquaredDiff += diff * diff;
+    }
+
+    return Math.sqrt(sumSquaredDiff);
+  }
+
+  /**
+   * 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[] {
+    // Üres jelölt-halmaz → nincs mit keresni (a `undefined` viszont „nincs szűrés" = teljes pool).
+    if (candidateIds && candidateIds.size === 0) {
+      return [];
+    }
+    if (!Array.isArray(query) || query.length === 0) {
+      throw new Error('Query vector must be a non-empty array');
+    }
+
+    if (k <= 0) {
+      throw new Error('k must be a positive number');
+    }
+
+    // `normalizedOnly` módban nincs nyers pool → l2Distance nem számolható (csak cosine).
+    if (this.normalizedOnly && mode === LVS_Search_Mode.l2Distance) {
+      throw new Error('l2Distance search is not available in normalizedOnly mode (raw vectors are not stored)');
+    }
+
+    // Üres pool → üres eredmény. A `normalizedVectorPool` a forrás (mindkét módban populált; a nyers
+    // `vectorPool` `normalizedOnly`-ban üres, ezért NEM azon ellenőrzünk).
+    if (this.normalizedVectorPool.size === 0) {
+      return [];
+    }
+
+    // Validáljuk, hogy minden vektor ugyanolyan dimenziójú-e. A referencia-pool mód-függő: l2 a nyers,
+    // cosine a normalizált (azonos dimenzió, de `normalizedOnly`-ban a nyers pool üres).
+    const referencePool: Map<string, number[]> =
+      mode === LVS_Search_Mode.l2Distance ? this.vectorPool : this.normalizedVectorPool;
+    const firstVector: number[] | undefined = Array.from(referencePool.values())[0];
+    if (firstVector && firstVector.length !== query.length) {
+      throw new Error(
+        `Query vector dimension (${query.length}) does not match pool vector ` +
+        `dimension (${firstVector.length})`
+      );
+    }
+
+    // Számoljuk ki a hasonlóságot/távolságot minden vektorra
+    const results: LVS_SearchResult[] = [];
+
+    if (mode === LVS_Search_Mode.cosineSimilarity) {
+      // PERF (BFR-AM-013): a query-t EGYSZER normalizáljuk, majd dot-product a MÁR ELŐRE eltárolt
+      // `normalizedVectorPool` (l2-normalizált) vektorok ellen. Eredmény AZONOS a régi
+      // `cosineSimilarity(query, vector)`-ral (= dot(norm(q), norm(v))), de:
+      //  (1) NEM normalizáljuk újra MINDEN vektort MINDEN keresésnél (a normalizálás a `addVector`-ban
+      //      egyszer megtörtént) → ~3× kevesebb FLOP;
+      //  (2) a per-összehasonlítás dot-product ALLOKÁCIÓ-MENTES (a régi `l2Normalize` hívásonként KÉT új
+      //      tömböt allokált → egy 24k-vektoros keresés ~48k tömb-allokáció + GC-spike-ot okozott).
+      // A drágán eltárolt `normalizedVectorPool` korábban SOHA nem volt használva a keresésben.
+      const queryNormalized: number[] = LVS_VectorPool_ControlService.l2Normalize(query);
+      for (const [id, normalizedVector] of this.normalizedVectorPool.entries()) {
+        if (candidateIds && !candidateIds.has(id)) {
+          continue;
+        }
+        let dotProduct: number = 0;
+        for (let i: number = 0; i < queryNormalized.length; i++) {
+          dotProduct += queryNormalized[i] * normalizedVector[i];
+        }
+        results.push({ id, score: dotProduct });
+      }
+      // Cosine similarity: csökkenő sorrend (legnagyobb hasonlóság először)
+      results.sort((a: LVS_SearchResult, b: LVS_SearchResult) => b.score - a.score);
+    } else if (mode === LVS_Search_Mode.l2Distance) {
+      for (const [id, vector] of this.vectorPool.entries()) {
+        if (candidateIds && !candidateIds.has(id)) {
+          continue;
+        }
+        results.push({ id, score: LVS_VectorPool_ControlService.l2Distance(query, vector) });
+      }
+      // L2 distance: növekvő sorrend (legkisebb távolság először)
+      results.sort((a: LVS_SearchResult, b: LVS_SearchResult) => a.score - b.score);
+    } else {
+      throw new Error(`Unknown search mode: ${mode}`);
+    }
+
+    // Visszaadjuk a top-K találatot
+    return results.slice(0, k);
+  }
+}
+

package/src/_modules/local-vector-search/index.ts

@@ -1,17 +1,17 @@
-
-
-// ENUMS
-export * from './_enums/lvs-search-mode.enum';
-
-// INTERFACES
-export * from './_models/lvs-search-result.interface';
-
-// DATA MODELS
-export * from './_models/data-models/lvs-vector-persist.data-model';
-
-// SERVICES
-export * from './_services/lvs-doc-chunk-data.service';
-export * from './_services/lvs-local-vector-search.data-service';
-export * from './_services/lvs-vector-pool.control-service';
-export * from './_services/lvs-vector-persist.data-service';
+
+
+// ENUMS
+export * from './_enums/lvs-search-mode.enum';
+
+// INTERFACES
+export * from './_models/lvs-search-result.interface';
+
+// DATA MODELS
+export * from './_models/data-models/lvs-vector-persist.data-model';
+
+// SERVICES
+export * from './_services/lvs-doc-chunk-data.service';
+export * from './_services/lvs-local-vector-search.data-service';
+export * from './_services/lvs-vector-pool.control-service';
+export * from './_services/lvs-vector-persist.data-service';
 export * from './_services/lvs-persistent-vector-pool.control-service';

package/src/_modules/logs/index.ts

@@ -1,11 +1,11 @@
-export { DyNTS_Logs_Service } from './logs.service';
-export { DyNTS_Logs_Controller, DyNTS_LogsController_Config } from './logs.controller';
-export { DyNTS_getLogsRoutingModule } from './get-logs-routing-module.util';
-export { DyNTS_FileLog_Service } from './file-log.service';
-export { DyNTS_FileLogs_Controller, DyNTS_FileLogsController_Config } from './file-logs.controller';
-export {
-  DyNTS_getFileLogsRoutingModule,
-  DyNTS_FileLogsRoutingModule_Config,
-} from './get-file-logs-routing-module.util';
-export { DyNTS_FileLog_Entry } from './_models/file-log-entry.interface';
-export { DyNTS_FileLog_ReadResult, DyNTS_FileLog_ReadOptions } from './_models/file-log-read-result.interface';
+export { DyNTS_Logs_Service } from './logs.service';
+export { DyNTS_Logs_Controller, DyNTS_LogsController_Config } from './logs.controller';
+export { DyNTS_getLogsRoutingModule } from './get-logs-routing-module.util';
+export { DyNTS_FileLog_Service } from './file-log.service';
+export { DyNTS_FileLogs_Controller, DyNTS_FileLogsController_Config } from './file-logs.controller';
+export {
+  DyNTS_getFileLogsRoutingModule,
+  DyNTS_FileLogsRoutingModule_Config,
+} from './get-file-logs-routing-module.util';
+export { DyNTS_FileLog_Entry } from './_models/file-log-entry.interface';
+export { DyNTS_FileLog_ReadResult, DyNTS_FileLog_ReadOptions } from './_models/file-log-read-result.interface';