agentic-qe 3.9.5 → 3.9.7

package/dist/kernel/native-hnsw-backend.js

@@ -1,28 +1,55 @@
 /**
- * Native HNSW Backend via @ruvector/router VectorDb
+ * Native HNSW Backend via hnswlib-node
  *
- * Provides a high-performance HNSW index backed by the Rust-based
- * @ruvector/router library. This backend implements the same
- * IHnswIndexProvider interface as ProgressiveHnswBackend but delegates
- * vector storage and search to native code for lower latency and
- * higher throughput.
+ * Provides a high-performance HNSW index backed by hnswlib-node, the
+ * canonical Node.js binding for the C++ Hnswlib reference implementation
+ * (Yury Malkov's HNSW library, the same code Pinecone, Weaviate, Qdrant
+ * and chromadb-default-embed are built on top of).
  *
- * When @ruvector/router is unavailable (e.g., unsupported platform,
- * missing binary), construction throws NativeHnswUnavailableError so the
- * caller (HnswAdapter factory) can fall back to the JS backend.
+ * This backend implements the same IHnswIndexProvider interface as
+ * ProgressiveHnswBackend but delegates vector storage and search to
+ * native code for sublinear search latency on large indexes.
  *
- * @see ADR-081: Native HNSW NAPI Integration
+ * History — issue #399 (April 2026):
+ *   This backend previously wrapped @ruvector/router's VectorDb. Empirical
+ *   verification (scripts/diagnose-issue-399*.mjs) found four serious bugs
+ *   in @ruvector/router 0.1.28:
+ *
+ *   1. HNSW search returned essentially random results — recall@10 ≈ 0%
+ *      on textbook unit-Gaussian random vectors at default M/efC/efS,
+ *      could not find self-vectors. Pumping efSearch to N≈index-size
+ *      restored correctness but defeated HNSW's purpose.
+ *   2. The VectorDb constructor unconditionally created a `vectors.db`
+ *      redb file in the current working directory (NOT in .agentic-qe/),
+ *      violating the unified memory architecture and polluting users'
+ *      project roots with multi-MB persistence files they never asked for.
+ *   3. The redb file held a process-wide exclusive lock — only ONE
+ *      VectorDb instance could exist per process. Subsequent constructors
+ *      threw "Database already open. Cannot acquire lock."
+ *   4. NAPI dispose did not synchronously release the redb lock, so the
+ *      lock outlived our dispose() call and caused the v3.9.5 futex
+ *      deadlock when the indexer tried to recreate after reset.
+ *
+ *   Comparison test on 1000 vector self-query (linux-arm64, M=16, efC=200,
+ *   efS=100, cosine):
+ *     - @ruvector/router 0.1.28: recall@10 = 10%, top-1 = wrong vector
+ *     - hnswlib-node 3.0.0:      recall@10 = 100%, top-1 = id 42 ✓
+ *
+ *   The migration to hnswlib-node fixes all four bugs in one swap.
+ *
+ * @see ADR-090: hnswlib-node migration
+ * @see https://github.com/proffesor-for-testing/agentic-qe/issues/399
  * @module kernel/native-hnsw-backend
  */
 import { createRequire } from 'module';
 import { DEFAULT_HNSW_CONFIG } from './hnsw-index-provider.js';
-// Use createRequire for @ruvector/router (native CJS/NAPI module)
+// hnswlib-node is a native CommonJS module distributed via node-gyp
 const esmRequire = createRequire(import.meta.url);
 // ============================================================================
 // Error Types
 // ============================================================================
 /**
- * Thrown when @ruvector/router native binary is not available.
+ * Thrown when hnswlib-node native binary is not available.
  * The HnswAdapter factory catches this to fall back to the JS backend.
  */
 export class NativeHnswUnavailableError extends Error {
@@ -38,7 +65,7 @@ let nativeModule = null;
 let nativeLoadAttempted = false;
 let nativeLoadError = null;
 /**
- * Attempt to load the @ruvector/router native module.
+ * Attempt to load the hnswlib-node native module.
  * Caches the result so subsequent calls are instant.
  */
 function loadNativeModule() {
@@ -49,11 +76,10 @@ function loadNativeModule() {
     }
     nativeLoadAttempted = true;
     try {
-        // Use createRequire for the optional native NAPI dependency
-        const mod = esmRequire('@ruvector/router');
-        // Verify the module has the expected API
-        if (!mod.VectorDb || !mod.DistanceMetric) {
-            throw new Error('@ruvector/router module missing VectorDb or DistanceMetric exports');
+        // hnswlib-node ships a CommonJS default export with HierarchicalNSW on it
+        const mod = esmRequire('hnswlib-node');
+        if (!mod.HierarchicalNSW) {
+            throw new Error('hnswlib-node module missing HierarchicalNSW export');
         }
         nativeModule = mod;
         return nativeModule;
@@ -88,22 +114,6 @@ export function isNativeModuleAvailable() {
 // ============================================================================
 // Vector Math Helpers
 // ============================================================================
-function computeNorm(v) {
-    let sum = 0;
-    for (let i = 0; i < v.length; i++)
-        sum += v[i] * v[i];
-    return Math.sqrt(sum);
-}
-function fastCosineSimilarity(a, b, normA, normB) {
-    const denom = normA * normB;
-    if (denom === 0)
-        return 0;
-    let dot = 0;
-    const len = Math.min(a.length, b.length);
-    for (let i = 0; i < len; i++)
-        dot += a[i] * b[i];
-    return dot / denom;
-}
 /**
  * Resize a vector to the target dimensions.
  * Shrink: average adjacent values. Grow: zero-pad.
@@ -131,29 +141,47 @@ function resizeVector(vector, targetDim) {
     }
     return result;
 }
+/**
+ * Convert a Float32Array to a plain number[] (required by hnswlib-node API).
+ */
+function toNumberArray(v) {
+    const out = new Array(v.length);
+    for (let i = 0; i < v.length; i++)
+        out[i] = v[i];
+    return out;
+}
 // ============================================================================
 // NativeHnswBackend
 // ============================================================================
 /**
- * Native HNSW backend using @ruvector/router VectorDb.
+ * Initial maxElements capacity for a new HierarchicalNSW index. The index
+ * will be doubled in place via resizeIndex() each time it fills up, so this
+ * value only controls the initial allocation cost. Tuned for AQE's typical
+ * code-intelligence index size (~2.5k vectors today, expected to grow).
+ */
+const INITIAL_MAX_ELEMENTS = 10_000;
+/**
+ * Native HNSW backend using hnswlib-node HierarchicalNSW.
  *
  * Provides the same IHnswIndexProvider interface as ProgressiveHnswBackend
- * but delegates all vector operations to a Rust-based HNSW implementation
- * for improved performance.
+ * but delegates all vector operations to the C++ Hnswlib reference
+ * implementation for sublinear search latency at scale.
  *
- * Note: @ruvector/router VectorDb uses string IDs while IHnswIndexProvider
- * uses numeric IDs. Conversion is done via String(id) and Number(id).
- * VectorDb search returns distance scores (lower = closer) which are
- * converted to similarity scores (higher = closer) for consistency.
+ * Key differences from the previous @ruvector/router-backed implementation:
+ *   - No local vectorStore mirror — hnswlib-node returns correct distances
+ *     directly, so re-scoring is unnecessary.
+ *   - No process-wide singleton lock — multiple instances coexist.
+ *   - No vectors.db pollution — persistence is opt-in via writeIndex().
+ *   - resizeIndex() doubling on overflow — grows past initial maxElements.
  */
 export class NativeHnswBackend {
     config;
-    nativeDb = null;
+    nativeIndex = null;
+    currentMaxElements = INITIAL_MAX_ELEMENTS;
+    /** Tracks live ids so size() and remove() can correctly distinguish soft-deleted slots. */
+    liveIds = new Set();
+    /** Optional metadata mirror — only stored when callers attach metadata. */
     metadataStore = new Map();
-    vectorStore = new Map();
-    normStore = new Map();
-    operationLock = Promise.resolve();
-    highFallbackWarningEmitted = false;
     _metrics = {
         totalSearches: 0,
         totalAdds: 0,
@@ -171,148 +199,161 @@ export class NativeHnswBackend {
      * Create a NativeHnswBackend.
      *
      * @param config - HNSW configuration overrides
-     * @throws {NativeHnswUnavailableError} If @ruvector/router is not available
+     * @throws {NativeHnswUnavailableError} If hnswlib-node is not available
      */
     constructor(config) {
         this.config = { ...DEFAULT_HNSW_CONFIG, ...config };
-        // Attempt to load native module and create VectorDb immediately.
-        // If the native module is unavailable or the database can't be opened,
-        // this throws NativeHnswUnavailableError so the factory can fall back
-        // to ProgressiveHnswBackend.
+        this.nativeIndex = this.createFreshIndex();
+    }
+    /**
+     * Build a fresh HierarchicalNSW with the configured parameters.
+     *
+     * Used both at construction time and on `clear()` to guarantee a clean
+     * graph. hnswlib-node's `markDelete` is a soft tombstone — it leaves the
+     * graph node in place and only hides it from search. Across many cycles
+     * of `clear() → re-add` (which happens during long test runs that share
+     * the singleton HnswAdapter registry), the tombstoned slots can interact
+     * pathologically with `addPoint(label, replaceDeleted=true)` and produce
+     * duplicate-label results from `searchKnn`. Recreating the underlying
+     * index on `clear()` is the only way to guarantee O(1) clean state
+     * regardless of how the wrapper is used over time.
+     */
+    createFreshIndex() {
         const native = loadNativeModule();
-        const distanceMetric = this.config.metric === 'cosine'
-            ? native.DistanceMetric.Cosine
-            : native.DistanceMetric.Euclidean;
+        const space = this.config.metric === 'euclidean' ? 'l2' : 'cosine';
         try {
-            this.nativeDb = new native.VectorDb({
-                dimensions: this.config.dimensions,
-                distanceMetric,
-                hnswM: this.config.M,
-                hnswEfConstruction: this.config.efConstruction,
-                hnswEfSearch: this.config.efSearch,
-            });
+            const idx = new native.HierarchicalNSW(space, this.config.dimensions);
+            idx.initIndex(this.currentMaxElements, this.config.M, this.config.efConstruction, 
+            // randomSeed: deterministic per-config seed so test runs are reproducible.
+            // hnswlib-node uses this to randomize level assignment during graph construction.
+            100, 
+            // allowReplaceDeleted: true so markDelete()-ed slots can be reused by future addPoint().
+            true);
+            idx.setEf(this.config.efSearch);
+            return idx;
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            throw new NativeHnswUnavailableError(`VectorDb creation failed: ${message}`);
+            throw new NativeHnswUnavailableError(`HierarchicalNSW init failed: ${message}`);
         }
     }
     // ============================================================================
     // IHnswIndexProvider Implementation
     // ============================================================================
     add(id, vector, metadata) {
+        if (!this.nativeIndex) {
+            throw new Error('NativeHnswBackend has been disposed');
+        }
         const normalized = this.normalizeVector(vector);
-        const norm = computeNorm(normalized);
-        // Remove existing entry if updating
-        if (this.vectorStore.has(id)) {
-            try {
-                this.nativeDb.delete(String(id));
-            }
-            catch { /* ignore if not found */ }
+        // Grow the index if we're about to overflow. hnswlib-node's resizeIndex
+        // doubles in-place; this gives amortized O(1) growth at the cost of a
+        // single memcpy on each doubling. Required for production use cases
+        // where the index size is not known at construction time.
+        if (!this.liveIds.has(id) && this.liveIds.size >= this.currentMaxElements) {
+            const newMax = this.currentMaxElements * 2;
+            this.nativeIndex.resizeIndex(newMax);
+            this.currentMaxElements = newMax;
         }
-        this.nativeDb.insert(String(id), normalized);
-        this.vectorStore.set(id, normalized);
-        this.normStore.set(id, norm);
+        // hnswlib-node treats addPoint with an existing label as an UPDATE.
+        // The replaceDeleted flag lets us reuse soft-deleted slots transparently.
+        this.nativeIndex.addPoint(toNumberArray(normalized), id, true);
+        this.liveIds.add(id);
         if (metadata) {
             this.metadataStore.set(id, metadata);
         }
+        else {
+            this.metadataStore.delete(id);
+        }
         this._metrics.totalAdds++;
     }
     search(query, k) {
-        const start = performance.now();
-        if (this.vectorStore.size === 0)
+        if (!this.nativeIndex) {
+            throw new Error('NativeHnswBackend has been disposed');
+        }
+        if (this.liveIds.size === 0 || k <= 0)
             return [];
+        const start = performance.now();
         const normalizedQuery = this.normalizeVector(query);
-        const queryNorm = computeNorm(normalizedQuery);
-        const actualK = Math.min(k, this.vectorStore.size);
-        let results;
-        try {
-            const nativeResults = this.nativeDb.search(normalizedQuery, actualK);
-            // Convert native distance scores to similarity scores.
-            // @ruvector/router returns { id: string, score: number } where
-            // score is a distance (lower = closer). We convert string IDs
-            // back to numbers and compute cosine similarity for consistency.
-            results = nativeResults.map((nr) => {
-                const numericId = Number(nr.id);
-                const storedVector = this.vectorStore.get(numericId);
-                const storedNorm = this.normStore.get(numericId) ?? 0;
-                // Compute cosine similarity for consistent scoring with ProgressiveHnswBackend
-                let score;
-                if (this.config.metric === 'cosine' && storedVector) {
-                    score = fastCosineSimilarity(normalizedQuery, storedVector, queryNorm, storedNorm);
-                }
-                else {
-                    // For euclidean, negate the distance (higher = closer)
-                    score = -nr.score;
-                }
-                return {
-                    id: numericId,
-                    score,
-                    metadata: this.metadataStore.get(numericId),
-                };
-            });
-            // Sort by descending score for consistency
-            results.sort((a, b) => b.score - a.score);
-            this._metrics.nativeSearchCount++;
-        }
-        catch {
-            // If native search fails, fall back to brute-force over stored vectors
-            this._metrics.fallbackSearchCount++;
-            this._metrics.bruteForceSearchCount++;
-            console.warn(`[NativeHNSW] FALLBACK: Using brute-force linear scan (@ruvector/router search failed). Index size: ${this.vectorStore.size}`);
-            results = this.bruteForceSearch(normalizedQuery, queryNorm, actualK);
+        const actualK = Math.min(k, this.liveIds.size);
+        // Overshoot k by 2x (capped at index size) so that defensive dedup
+        // below can drop any duplicate-label entries hnswlib may return after
+        // long add/remove churn and still leave us with at least k unique
+        // results when possible.
+        const overshoot = Math.min(actualK * 2, this.liveIds.size);
+        const native = this.nativeIndex.searchKnn(toNumberArray(normalizedQuery), overshoot);
+        // Convert hnswlib-node distances to similarity scores.
+        //   cosine space: distance = 1 - cos_sim, so similarity = 1 - distance
+        //   l2 space:     distance = sum((x_i - y_i)^2), no clean similarity;
+        //                 we negate so that "higher = closer" remains the contract
+        const isCosine = this.config.metric === 'cosine';
+        // Defensive dedup: keep only the best score for each id. hnswlib-node
+        // can return duplicate labels after pathological add/remove cycles
+        // (verified empirically — see ADR-090 / issue #399 follow-up). We
+        // can't fix the C++ side from here, but we can make sure callers
+        // never see duplicates by collapsing them at the wrapper boundary.
+        const seen = new Map();
+        for (let i = 0; i < native.neighbors.length; i++) {
+            const id = native.neighbors[i];
+            // Skip ids we've already removed at the wrapper level. liveIds is
+            // the source of truth for "is this id currently in the index" —
+            // hnswlib's internal markDelete state can lag.
+            if (!this.liveIds.has(id))
+                continue;
+            const distance = native.distances[i];
+            const score = isCosine ? 1 - distance : -distance;
+            const existing = seen.get(id);
+            if (existing === undefined || score > existing.score) {
+                seen.set(id, { id, score, metadata: this.metadataStore.get(id) });
+            }
         }
+        const results = Array.from(seen.values());
+        // hnswlib-node returns results in ascending distance order (best first
+        // for distance), but our SearchResult contract is descending score
+        // (best first for similarity). Sort defensively to guarantee the
+        // contract regardless of how the metric maps.
+        results.sort((a, b) => b.score - a.score);
+        // Truncate to the requested k after dedup.
+        if (results.length > actualK)
+            results.length = actualK;
         const elapsed = performance.now() - start;
         this.updateSearchMetrics(elapsed);
-        // Compute derived fallback metrics
-        this._metrics.fallbackRate =
-            this._metrics.fallbackSearchCount / this._metrics.totalSearches;
-        this._metrics.allSearchesBruteForce =
-            this._metrics.nativeSearchCount === 0 && this._metrics.totalSearches > 0;
-        // One-time warning when fallback rate is dangerously high
-        if (!this.highFallbackWarningEmitted &&
-            this._metrics.fallbackRate > 0.5 &&
-            this._metrics.totalSearches >= 10) {
-            this.highFallbackWarningEmitted = true;
-            console.error(`[NativeHNSW] WARNING: ${(this._metrics.fallbackRate * 100).toFixed(0)}% of searches are using brute-force fallback. Native HNSW may not be functioning correctly. Consider rebuilding the index or checking @ruvector/router installation.`);
-        }
+        this._metrics.nativeSearchCount = this._metrics.totalSearches;
         if (elapsed > 50) {
             console.warn(`[NativeHNSW] search took ${elapsed.toFixed(1)}ms (k=${k}, results=${results.length})`);
         }
         return results;
     }
     remove(id) {
-        if (!this.vectorStore.has(id))
+        if (!this.nativeIndex)
+            return false;
+        if (!this.liveIds.has(id))
             return false;
         try {
-            this.nativeDb.delete(String(id));
+            this.nativeIndex.markDelete(id);
         }
         catch {
-            // Native remove failed; clean up local state anyway
+            // markDelete throws if the label was never added; treat as not-found.
+            return false;
         }
-        this.vectorStore.delete(id);
-        this.normStore.delete(id);
+        this.liveIds.delete(id);
         this.metadataStore.delete(id);
         this._metrics.totalRemoves++;
         return true;
     }
     size() {
-        return this.vectorStore.size;
+        return this.liveIds.size;
     }
     dimensions() {
         return this.config.dimensions;
     }
     recall() {
-        // HNSW is approximate, estimate recall based on efSearch/M ratio
-        // Higher efSearch relative to M means better recall
-        const ratio = this.config.efSearch / this.config.M;
-        if (ratio >= 10)
-            return 0.99;
-        if (ratio >= 5)
-            return 0.97;
-        if (ratio >= 3)
-            return 0.95;
-        return 0.90;
+        // hnswlib-node with default M=16, efConstruction=200, efSearch=100 hits
+        // 100% recall@10 on the project's own qe-kernel fixture and on textbook
+        // Gaussian random vectors (verified empirically — see ADR-090). At very
+        // large N or aggressively low efSearch, recall is approximate; we report
+        // a slightly conservative 0.99 to make that property visible to callers
+        // that care about the difference between exact and approximate search.
+        return 0.99;
     }
     // ============================================================================
     // Public Utilities
@@ -337,45 +378,47 @@ export class NativeHnswBackend {
     }
     /**
      * Clear all vectors from the index.
-     * Deletes all entries from the native VectorDb.
+     *
+     * Recreates the underlying HierarchicalNSW from scratch rather than
+     * `markDelete`-ing each label. The tombstone-only approach leaks state
+     * across `clear() → re-add` cycles (the C++ graph keeps every deleted
+     * slot, and `addPoint(label, replaceDeleted=true)` can produce
+     * duplicate-label results from `searchKnn` after many cycles). A fresh
+     * index is the only guarantee of O(1) clean state and is what callers
+     * who use `clear()` actually expect.
      */
     clear() {
-        if (!this.nativeDb)
+        if (!this.nativeIndex)
             return;
-        // Delete all entries from native DB
-        for (const id of this.vectorStore.keys()) {
-            try {
-                this.nativeDb.delete(String(id));
-            }
-            catch { /* ignore */ }
-        }
-        this.vectorStore.clear();
-        this.normStore.clear();
+        this.liveIds.clear();
         this.metadataStore.clear();
+        // Reset capacity to the initial value so a fresh index doesn't carry
+        // over the previous index's resize history.
+        this.currentMaxElements = INITIAL_MAX_ELEMENTS;
+        this.nativeIndex = this.createFreshIndex();
     }
     /**
-     * Dispose of the native VectorDb handle so NAPI garbage collection can
-     * reclaim the underlying Rust-side index. After dispose(), this backend
-     * instance must not be used. The HnswAdapter registry is expected to
-     * drop its reference as part of `HnswAdapter.close(name)`.
+     * Dispose of the native index handle.
+     *
+     * hnswlib-node holds the C++ index in JS-managed memory; setting the
+     * reference to null lets V8 GC reclaim it on the next collection cycle.
+     * Unlike the previous @ruvector/router VectorDb, there is no file lock
+     * to release and no synchronous teardown required.
      *
-     * This is the load-bearing fix for the v3.9.1 regression where
-     * `resetUnifiedMemory()` would null the UnifiedMemoryManager but leave
-     * a stale NativeHnswBackend alive in the HnswAdapter registry.
+     * After dispose(), this backend instance must not be used. The
+     * HnswAdapter registry is expected to drop its reference as part of
+     * `HnswAdapter.close(name)`.
      */
     dispose() {
-        // Clear local mirrors first so `clear()` on a dead nativeDb is a no-op.
-        this.vectorStore.clear();
-        this.normStore.clear();
+        this.liveIds.clear();
         this.metadataStore.clear();
-        // Drop the native handle. Rust-side VectorDb is reclaimed by NAPI GC.
-        this.nativeDb = null;
+        this.nativeIndex = null;
     }
     /**
      * Check if the native backend is operational.
      */
     isNativeAvailable() {
-        return this.nativeDb !== null;
+        return this.nativeIndex !== null;
     }
     // ============================================================================
     // Private Helpers
@@ -396,33 +439,5 @@ export class NativeHnswBackend {
         this._metrics.avgSearchLatencyMs =
             this._metrics.avgSearchLatencyMs * ((n - 1) / n) + latencyMs / n;
     }
-    /**
-     * Brute-force fallback search over locally stored vectors.
-     * Used when native search throws an unexpected error.
-     */
-    bruteForceSearch(query, queryNorm, k) {
-        const scored = [];
-        for (const [id, vector] of this.vectorStore) {
-            const norm = this.normStore.get(id) ?? computeNorm(vector);
-            const score = this.config.metric === 'cosine'
-                ? fastCosineSimilarity(query, vector, queryNorm, norm)
-                : -(function () {
-                    let sum = 0;
-                    const len = Math.min(query.length, vector.length);
-                    for (let i = 0; i < len; i++) {
-                        const diff = query[i] - vector[i];
-                        sum += diff * diff;
-                    }
-                    return Math.sqrt(sum);
-                })();
-            scored.push({
-                id,
-                score,
-                metadata: this.metadataStore.get(id),
-            });
-        }
-        scored.sort((a, b) => b.score - a.score);
-        return scored.slice(0, k);
-    }
 }
 //# sourceMappingURL=native-hnsw-backend.js.map

package/dist/kernel/unified-memory.js

@@ -807,16 +807,21 @@ export class UnifiedMemoryManager {
     close() {
         if (this.db) {
             this.preparedStatements.clear();
-            // IMPORTANT: vectorIndex.clear() empties the vectors but does NOT
-            // dispose the backend. The underlying NativeHnswBackend (if native
-            // HNSW is enabled) holds a native VectorDb that is process-global
-            // — @ruvector/router does not allow a second VectorDb to be
-            // created in the same process while the first is still alive
-            // ("Database already open. Cannot acquire lock."). We deliberately
-            // keep the HnswAdapter alive in its registry so the next
-            // UnifiedMemoryManager instance re-binds to the same backend.
-            // See fix/init-v3-9-3 Fix 1 for the dispose() plumbing that tests
-            // and explicit shutdown paths can use via HnswAdapter.close(name).
+            // vectorIndex.clear() recreates the underlying HierarchicalNSW
+            // (post #399 / ADR-090 — see NativeHnswBackend.clear()), so the
+            // next UnifiedMemoryManager instance starts with a fresh graph.
+            // The HnswAdapter registry singleton is intentionally preserved
+            // across close()/re-init cycles so that consumers that hold a
+            // reference to the named adapter (e.g. PatternStore) continue to
+            // see live state. Tests and explicit shutdown paths can fully
+            // tear down via HnswAdapter.close(name).
+            //
+            // Historical context: prior to #399, NativeHnswBackend wrapped
+            // @ruvector/router's VectorDb which held a process-wide redb file
+            // lock — only ONE instance could exist per process and the lock
+            // was not released by NAPI dispose ("Database already open").
+            // hnswlib-node has none of those constraints; multiple instances
+            // coexist freely.
             this.vectorIndex.clear();
             this.db.close();
             this.db = null;