agentdb 1.0.11 → 1.1.0

package/dist/index/hnsw.mjs

@@ -1,516 +0,0 @@
-/**
- * HNSW (Hierarchical Navigable Small World) Index Implementation
- * High-performance approximate nearest neighbor search with O(log n) complexity
- *
- * Algorithm: Hierarchical graph structure with multiple layers
- * - Layer 0: All vectors with dense connections
- * - Higher layers: Sparse long-range connections for efficient navigation
- *
- * Performance targets:
- * - Search: <10ms for 10K vectors
- * - Build: <5s for 10K vectors
- * - Recall: >95% accuracy
- */
-/**
- * Default HNSW configuration optimized for most use cases
- */
-export const DEFAULT_HNSW_CONFIG = {
-    M: 16,
-    M0: 32,
-    efConstruction: 200,
-    efSearch: 50,
-    mL: 1 / Math.log(16),
-    minVectorsForIndex: 1000,
-    autoRebuild: false,
-    enabled: true
-};
-/**
- * HNSW Index implementation
- */
-export class HNSWIndex {
-    constructor(db, config = {}) {
-        this.entryPoint = null;
-        this.maxLevel = 0;
-        this.isBuilt = false;
-        this.db = db;
-        this.config = { ...DEFAULT_HNSW_CONFIG, ...config };
-        this.initializeSchema();
-        this.prepareStatements();
-        this.loadMetadata();
-    }
-    /**
-     * Initialize HNSW schema in SQLite
-     */
-    initializeSchema() {
-        // Create HNSW nodes table
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS hnsw_nodes (
-        id TEXT PRIMARY KEY,
-        vector_id TEXT NOT NULL,
-        level INTEGER NOT NULL,
-        embedding BLOB NOT NULL,
-        FOREIGN KEY (vector_id) REFERENCES vectors(id) ON DELETE CASCADE
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_hnsw_nodes_vector ON hnsw_nodes(vector_id);
-      CREATE INDEX IF NOT EXISTS idx_hnsw_nodes_level ON hnsw_nodes(level);
-    `);
-        // Create HNSW edges table
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS hnsw_edges (
-        from_id TEXT NOT NULL,
-        to_id TEXT NOT NULL,
-        level INTEGER NOT NULL,
-        distance REAL NOT NULL,
-        PRIMARY KEY (from_id, to_id, level),
-        FOREIGN KEY (from_id) REFERENCES hnsw_nodes(id) ON DELETE CASCADE,
-        FOREIGN KEY (to_id) REFERENCES hnsw_nodes(id) ON DELETE CASCADE
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_hnsw_edges_from ON hnsw_edges(from_id, level);
-      CREATE INDEX IF NOT EXISTS idx_hnsw_edges_to ON hnsw_edges(to_id, level);
-      CREATE INDEX IF NOT EXISTS idx_hnsw_edges_level ON hnsw_edges(level);
-    `);
-        // Create metadata table for index state
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS hnsw_metadata (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      );
-    `);
-    }
-    /**
-     * Prepare frequently used SQL statements
-     */
-    prepareStatements() {
-        this.insertNodeStmt = this.db.prepare(`
-      INSERT OR REPLACE INTO hnsw_nodes (id, vector_id, level, embedding)
-      VALUES (?, ?, ?, ?)
-    `);
-        this.insertEdgeStmt = this.db.prepare(`
-      INSERT OR REPLACE INTO hnsw_edges (from_id, to_id, level, distance)
-      VALUES (?, ?, ?, ?)
-    `);
-        this.getNodeStmt = this.db.prepare(`
-      SELECT id, vector_id, level, embedding
-      FROM hnsw_nodes
-      WHERE id = ?
-    `);
-        this.getNeighborsStmt = this.db.prepare(`
-      SELECT to_id, distance
-      FROM hnsw_edges
-      WHERE from_id = ? AND level = ?
-      ORDER BY distance ASC
-    `);
-        this.deleteNodeStmt = this.db.prepare(`
-      DELETE FROM hnsw_nodes WHERE id = ?
-    `);
-        this.deleteEdgesStmt = this.db.prepare(`
-      DELETE FROM hnsw_edges WHERE from_id = ? OR to_id = ?
-    `);
-    }
-    /**
-     * Load metadata from database
-     */
-    loadMetadata() {
-        const stmt = this.db.prepare('SELECT value FROM hnsw_metadata WHERE key = ?');
-        const entryPointRow = stmt.get('entry_point');
-        if (entryPointRow) {
-            this.entryPoint = entryPointRow.value;
-        }
-        const maxLevelRow = stmt.get('max_level');
-        if (maxLevelRow) {
-            this.maxLevel = parseInt(maxLevelRow.value, 10);
-        }
-        const isBuiltRow = stmt.get('is_built');
-        if (isBuiltRow) {
-            this.isBuilt = isBuiltRow.value === 'true';
-        }
-    }
-    /**
-     * Save metadata to database
-     */
-    saveMetadata() {
-        const stmt = this.db.prepare('INSERT OR REPLACE INTO hnsw_metadata (key, value) VALUES (?, ?)');
-        if (this.entryPoint) {
-            stmt.run('entry_point', this.entryPoint);
-        }
-        stmt.run('max_level', this.maxLevel.toString());
-        stmt.run('is_built', this.isBuilt.toString());
-    }
-    /**
-     * Calculate random level for new node using exponential decay
-     */
-    randomLevel() {
-        let level = 0;
-        while (Math.random() < this.config.mL && level < 16) {
-            level++;
-        }
-        return level;
-    }
-    /**
-     * Calculate Euclidean distance between two vectors
-     */
-    calculateDistance(a, b) {
-        let sum = 0;
-        for (let i = 0; i < a.length; i++) {
-            const diff = a[i] - b[i];
-            sum += diff * diff;
-        }
-        return Math.sqrt(sum);
-    }
-    /**
-     * Serialize embedding to Buffer
-     */
-    serializeEmbedding(embedding) {
-        const buffer = Buffer.allocUnsafe(embedding.length * 4);
-        const view = new Float32Array(buffer.buffer, buffer.byteOffset, embedding.length);
-        view.set(embedding);
-        return buffer;
-    }
-    /**
-     * Deserialize embedding from Buffer
-     */
-    deserializeEmbedding(buffer) {
-        const view = new Float32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4);
-        return Array.from(view);
-    }
-    /**
-     * Get node by ID
-     */
-    getNode(id) {
-        const row = this.getNodeStmt.get(id);
-        if (!row)
-            return null;
-        return {
-            id: row.id,
-            vectorId: row.vector_id,
-            level: row.level,
-            embedding: this.deserializeEmbedding(row.embedding)
-        };
-    }
-    /**
-     * Get neighbors of a node at a specific level
-     */
-    getNeighbors(nodeId, level) {
-        const rows = this.getNeighborsStmt.all(nodeId, level);
-        return rows.map(row => ({
-            id: row.to_id,
-            distance: row.distance
-        }));
-    }
-    /**
-     * Search for k nearest neighbors at a specific layer
-     */
-    searchLayer(query, entryPoints, ef, level) {
-        const visited = new Set();
-        const candidates = [];
-        const results = [];
-        // Initialize with entry points
-        for (const ep of entryPoints) {
-            const node = this.getNode(ep);
-            if (!node)
-                continue;
-            const distance = this.calculateDistance(query, node.embedding);
-            candidates.push({ id: ep, distance });
-            results.push({ id: ep, distance });
-            visited.add(ep);
-        }
-        // Sort candidates by distance (ascending)
-        candidates.sort((a, b) => a.distance - b.distance);
-        results.sort((a, b) => a.distance - b.distance);
-        // Beam search
-        while (candidates.length > 0) {
-            const current = candidates.shift();
-            // If current is farther than worst result, stop
-            if (results.length >= ef && current.distance > results[results.length - 1].distance) {
-                break;
-            }
-            // Explore neighbors
-            const neighbors = this.getNeighbors(current.id, level);
-            for (const neighbor of neighbors) {
-                if (visited.has(neighbor.id))
-                    continue;
-                visited.add(neighbor.id);
-                const node = this.getNode(neighbor.id);
-                if (!node)
-                    continue;
-                const distance = this.calculateDistance(query, node.embedding);
-                // Add to candidates if better than worst result
-                if (results.length < ef || distance < results[results.length - 1].distance) {
-                    candidates.push({ id: neighbor.id, distance });
-                    results.push({ id: neighbor.id, distance });
-                    // Keep results sorted and limited to ef
-                    results.sort((a, b) => a.distance - b.distance);
-                    if (results.length > ef) {
-                        results.pop();
-                    }
-                    // Keep candidates sorted
-                    candidates.sort((a, b) => a.distance - b.distance);
-                }
-            }
-        }
-        return results;
-    }
-    /**
-     * Select neighbors using heuristic (Alg 4 from HNSW paper)
-     */
-    selectNeighborsHeuristic(candidates, M) {
-        // Simple implementation: select M closest neighbors
-        candidates.sort((a, b) => a.distance - b.distance);
-        return candidates.slice(0, M);
-    }
-    /**
-     * Add bidirectional link between nodes
-     */
-    addEdge(fromId, toId, level, distance) {
-        this.insertEdgeStmt.run(fromId, toId, level, distance);
-        this.insertEdgeStmt.run(toId, fromId, level, distance);
-    }
-    /**
-     * Insert a new node into the HNSW index (optimized version)
-     */
-    insert(vectorId, embedding) {
-        const nodeId = `hnsw_${vectorId}`;
-        const level = this.randomLevel();
-        // Insert node
-        this.insertNodeStmt.run(nodeId, vectorId, level, this.serializeEmbedding(embedding));
-        // Update max level
-        if (level > this.maxLevel) {
-            this.maxLevel = level;
-        }
-        // If this is the first node, make it the entry point
-        if (!this.entryPoint) {
-            this.entryPoint = nodeId;
-            // Don't save metadata on every insert (batching will handle it)
-            return;
-        }
-        // Search for nearest neighbors at each layer
-        let entryPoints = [this.entryPoint];
-        // Navigate from top to target level
-        for (let lc = this.maxLevel; lc > level; lc--) {
-            const nearest = this.searchLayer(embedding, entryPoints, 1, lc);
-            if (nearest.length > 0) {
-                entryPoints = [nearest[0].id];
-            }
-        }
-        // Cache for prepared statement reuse
-        const deleteStmtCache = this.db.prepare(`
-      DELETE FROM hnsw_edges
-      WHERE (from_id = ? OR to_id = ?) AND level = ?
-    `);
-        // Insert at all levels from level to 0
-        for (let lc = level; lc >= 0; lc--) {
-            const M = lc === 0 ? this.config.M0 : this.config.M;
-            const candidates = this.searchLayer(embedding, entryPoints, this.config.efConstruction, lc);
-            // Select M neighbors
-            const neighbors = this.selectNeighborsHeuristic(candidates, M);
-            // Add bidirectional links
-            for (const neighbor of neighbors) {
-                this.addEdge(nodeId, neighbor.id, lc, neighbor.distance);
-            }
-            // Prune neighbors' connections if needed (optimized)
-            for (const neighbor of neighbors) {
-                const neighborConnections = this.getNeighbors(neighbor.id, lc);
-                if (neighborConnections.length > M) {
-                    // Need to prune - remove edges and re-add selected ones
-                    deleteStmtCache.run(neighbor.id, neighbor.id, lc);
-                    // Re-select neighbors with minimal node fetching
-                    const node = this.getNode(neighbor.id);
-                    if (node) {
-                        // Batch fetch neighbor nodes for distance calculation
-                        const newCandidates = [];
-                        for (const nc of neighborConnections) {
-                            const n = this.getNode(nc.id);
-                            if (n) {
-                                newCandidates.push({
-                                    id: nc.id,
-                                    distance: this.calculateDistance(node.embedding, n.embedding)
-                                });
-                            }
-                        }
-                        const selected = this.selectNeighborsHeuristic(newCandidates, M);
-                        for (const sel of selected) {
-                            this.addEdge(neighbor.id, sel.id, lc, sel.distance);
-                        }
-                    }
-                }
-            }
-            entryPoints = neighbors.map(n => n.id);
-        }
-        this.isBuilt = true;
-        // Don't save metadata on every insert (batching will handle it)
-    }
-    /**
-     * Search for k nearest neighbors using HNSW index
-     */
-    search(query, k) {
-        if (!this.entryPoint || !this.isBuilt) {
-            return [];
-        }
-        let entryPoints = [this.entryPoint];
-        // Navigate from top layer to layer 0
-        for (let lc = this.maxLevel; lc > 0; lc--) {
-            const nearest = this.searchLayer(query, entryPoints, 1, lc);
-            if (nearest.length > 0) {
-                entryPoints = [nearest[0].id];
-            }
-        }
-        // Search at layer 0 with efSearch
-        const ef = Math.max(this.config.efSearch, k);
-        const results = this.searchLayer(query, entryPoints, ef, 0);
-        // Convert to final results with full node info
-        return results.slice(0, k).map(result => {
-            const node = this.getNode(result.id);
-            return {
-                id: result.id,
-                vectorId: node.vectorId,
-                distance: result.distance,
-                embedding: node.embedding
-            };
-        });
-    }
-    /**
-     * Build HNSW index from all vectors in database with optimizations
-     */
-    build() {
-        // Clear existing index
-        this.clear();
-        // Get all vectors from the main vectors table
-        const stmt = this.db.prepare('SELECT id, embedding FROM vectors ORDER BY id');
-        const rows = stmt.all();
-        if (rows.length === 0) {
-            console.log('No vectors to index');
-            return;
-        }
-        console.log(`Building HNSW index for ${rows.length} vectors...`);
-        const startTime = Date.now();
-        // Batch insert optimization: wrap in transaction
-        const transaction = this.db.transaction(() => {
-            // Insert all vectors into index
-            for (const row of rows) {
-                const embedding = this.deserializeEmbedding(row.embedding);
-                this.insert(row.id, embedding);
-            }
-        });
-        transaction();
-        const duration = Date.now() - startTime;
-        const perVector = duration / rows.length;
-        console.log(`HNSW index built in ${duration}ms (${perVector.toFixed(2)}ms per vector)`);
-        this.isBuilt = true;
-        this.saveMetadata();
-    }
-    /**
-     * Build index incrementally (non-blocking for large datasets)
-     */
-    async buildAsync(onProgress) {
-        // Clear existing index
-        this.clear();
-        // Get all vectors from the main vectors table
-        const stmt = this.db.prepare('SELECT id, embedding FROM vectors ORDER BY id');
-        const rows = stmt.all();
-        if (rows.length === 0) {
-            console.log('No vectors to index');
-            return;
-        }
-        console.log(`Building HNSW index incrementally for ${rows.length} vectors...`);
-        const startTime = Date.now();
-        const BATCH_SIZE = 100; // Process in batches to allow async breaks
-        for (let i = 0; i < rows.length; i += BATCH_SIZE) {
-            const batchStartTime = Date.now();
-            const batch = rows.slice(i, i + BATCH_SIZE);
-            // Process batch in transaction
-            const transaction = this.db.transaction(() => {
-                for (const row of batch) {
-                    const embedding = this.deserializeEmbedding(row.embedding);
-                    this.insert(row.id, embedding);
-                }
-            });
-            transaction();
-            const batchTime = Date.now() - batchStartTime;
-            // Report progress
-            if (onProgress) {
-                onProgress(i + batch.length, rows.length, Date.now() - startTime);
-            }
-            // Yield to event loop every batch
-            await new Promise(resolve => setImmediate(resolve));
-        }
-        const duration = Date.now() - startTime;
-        const perVector = duration / rows.length;
-        console.log(`HNSW index built incrementally in ${duration}ms (${perVector.toFixed(2)}ms per vector)`);
-        this.isBuilt = true;
-        this.saveMetadata();
-    }
-    /**
-     * Clear the entire index
-     */
-    clear() {
-        this.db.exec('DELETE FROM hnsw_edges');
-        this.db.exec('DELETE FROM hnsw_nodes');
-        this.db.exec('DELETE FROM hnsw_metadata');
-        this.entryPoint = null;
-        this.maxLevel = 0;
-        this.isBuilt = false;
-    }
-    /**
-     * Delete a node from the index
-     */
-    delete(vectorId) {
-        const nodeId = `hnsw_${vectorId}`;
-        // Check if node exists
-        const node = this.getNode(nodeId);
-        if (!node)
-            return;
-        // If this is the entry point, find a new one
-        if (this.entryPoint === nodeId) {
-            const stmt = this.db.prepare('SELECT id FROM hnsw_nodes WHERE id != ? LIMIT 1');
-            const row = stmt.get(nodeId);
-            this.entryPoint = row ? row.id : null;
-        }
-        // Delete edges
-        this.deleteEdgesStmt.run(nodeId, nodeId);
-        // Delete node
-        this.deleteNodeStmt.run(nodeId);
-        // Update metadata
-        if (!this.entryPoint) {
-            this.isBuilt = false;
-            this.maxLevel = 0;
-        }
-        this.saveMetadata();
-    }
-    /**
-     * Get index statistics
-     */
-    getStats() {
-        const nodeCountStmt = this.db.prepare('SELECT COUNT(*) as count FROM hnsw_nodes');
-        const edgeCountStmt = this.db.prepare('SELECT COUNT(*) as count FROM hnsw_edges');
-        const nodeCount = nodeCountStmt.get().count;
-        const edgeCount = edgeCountStmt.get().count;
-        const avgDegree = nodeCount > 0 ? edgeCount / nodeCount : 0;
-        return {
-            nodeCount,
-            edgeCount,
-            maxLevel: this.maxLevel,
-            isBuilt: this.isBuilt,
-            avgDegree
-        };
-    }
-    /**
-     * Check if index is ready to use
-     */
-    isReady() {
-        return this.isBuilt && this.entryPoint !== null;
-    }
-    /**
-     * Get configuration
-     */
-    getConfig() {
-        return { ...this.config };
-    }
-    /**
-     * Update configuration (requires rebuild)
-     */
-    updateConfig(config) {
-        this.config = { ...this.config, ...config };
-    }
-}

package/dist/index.browser.d.ts

@@ -1,47 +0,0 @@
-/**
- * AgentDB Browser Entry Point
- * Only includes WASM backend - no Node.js dependencies
- *
- * @module agentdb/browser
- * @packageDocumentation
- */
-import { SQLiteVectorDB } from './core/vector-db';
-import { WasmBackend } from './core/wasm-backend';
-import { BackendType, ExtendedDatabaseConfig, VectorBackend } from './core/backend-interface';
-import { initWasm, initSQL, getWasm, isInitialized, resetWasm } from './wasm-loader';
-export { SQLiteVectorDB };
-export { WasmBackend };
-export { BackendType };
-export type { VectorBackend, ExtendedDatabaseConfig };
-export { HNSWIndex, DEFAULT_HNSW_CONFIG } from './index/hnsw';
-export { OptimizedHNSWIndex } from './index/hnsw-optimized';
-export type { HNSWConfig } from './index/hnsw';
-export { QueryCache } from './cache/query-cache';
-export type { QueryCacheConfig, CacheStats } from './cache/query-cache';
-export { VectorQueryBuilder } from './query/query-builder';
-export type { Operator, SortDirection } from './query/query-builder';
-export { ProductQuantizer } from './quantization/product-quantization';
-export type { ProductQuantizerConfig, CompressionStats } from './quantization/product-quantization';
-export { ScalarQuantizer } from './quantization/scalar-quantization';
-export type { ScalarQuantizerConfig, AccuracyMetrics, ScalarQuantizationStats } from './quantization/scalar-quantization';
-export { ImprovedProductQuantizer, QuantizationProfiles, QuantizationUtils } from './quantization/optimized-pq';
-export type { QuantizationProfile } from './quantization/optimized-pq';
-export { BinaryQuantizer, createBinaryQuantizer } from './quantization/binary-quantization';
-export type { BinaryQuantizationConfig, BinaryQuantizationStats } from './quantization/binary-quantization';
-export type { Vector, SearchResult, SimilarityMetric, DatabaseConfig, VectorMetadata, QuantizationConfig } from './types';
-export type { Pattern, Experience, Context, LearningMetrics } from './types';
-export { initWasm, initSQL, getWasm, resetWasm };
-export { isInitialized as isWasmInitialized };
-/**
- * Convenience function to create a vector database (browser version)
- * Always uses WASM backend in browser
- */
-export declare function createVectorDB(config?: ExtendedDatabaseConfig): Promise<SQLiteVectorDB>;
-declare const _default: {
-    SQLiteVectorDB: typeof SQLiteVectorDB;
-    createVectorDB: typeof createVectorDB;
-    BackendType: typeof BackendType;
-    initWasm: typeof initWasm;
-};
-export default _default;
-//# sourceMappingURL=index.browser.d.ts.map

package/dist/index.browser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.browser.d.ts","sourceRoot":"","sources":["../src/index.browser.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9F,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAGrF,OAAO,EAAE,cAAc,EAAE,CAAC;AAC1B,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,CAAC;AAGtD,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG/C,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,YAAY,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAGxE,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,YAAY,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAGrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AACvE,YAAY,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AAGpG,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACrE,YAAY,EACV,qBAAqB,EACrB,eAAe,EACf,uBAAuB,EACxB,MAAM,oCAAoC,CAAC;AAG5C,OAAO,EACL,wBAAwB,EACxB,oBAAoB,EACpB,iBAAiB,EAClB,MAAM,6BAA6B,CAAC;AACrC,YAAY,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAGvE,OAAO,EACL,eAAe,EACf,qBAAqB,EACtB,MAAM,oCAAoC,CAAC;AAC5C,YAAY,EACV,wBAAwB,EACxB,uBAAuB,EACxB,MAAM,oCAAoC,CAAC;AAG5C,YAAY,EACV,MAAM,EACN,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,kBAAkB,EACnB,MAAM,SAAS,CAAC;AAGjB,YAAY,EACV,OAAO,EACP,UAAU,EACV,OAAO,EACP,eAAe,EAChB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;AACjD,OAAO,EAAE,aAAa,IAAI,iBAAiB,EAAE,CAAC;AAE9C;;;GAGG;AACH,wBAAsB,cAAc,CAAC,MAAM,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAAC,cAAc,CAAC,CAU7F;;;;;;;AAGD,wBAKE"}

package/dist/index.browser.js

@@ -1,72 +0,0 @@
-"use strict";
-/**
- * AgentDB Browser Entry Point
- * Only includes WASM backend - no Node.js dependencies
- *
- * @module agentdb/browser
- * @packageDocumentation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isWasmInitialized = exports.resetWasm = exports.getWasm = exports.initSQL = exports.initWasm = exports.createBinaryQuantizer = exports.BinaryQuantizer = exports.QuantizationUtils = exports.QuantizationProfiles = exports.ImprovedProductQuantizer = exports.ScalarQuantizer = exports.ProductQuantizer = exports.VectorQueryBuilder = exports.QueryCache = exports.OptimizedHNSWIndex = exports.DEFAULT_HNSW_CONFIG = exports.HNSWIndex = exports.BackendType = exports.WasmBackend = exports.SQLiteVectorDB = void 0;
-exports.createVectorDB = createVectorDB;
-// Main unified API (browser-compatible only)
-const vector_db_1 = require("./core/vector-db");
-Object.defineProperty(exports, "SQLiteVectorDB", { enumerable: true, get: function () { return vector_db_1.SQLiteVectorDB; } });
-const wasm_backend_1 = require("./core/wasm-backend");
-Object.defineProperty(exports, "WasmBackend", { enumerable: true, get: function () { return wasm_backend_1.WasmBackend; } });
-const backend_interface_1 = require("./core/backend-interface");
-Object.defineProperty(exports, "BackendType", { enumerable: true, get: function () { return backend_interface_1.BackendType; } });
-const wasm_loader_1 = require("./wasm-loader");
-Object.defineProperty(exports, "initWasm", { enumerable: true, get: function () { return wasm_loader_1.initWasm; } });
-Object.defineProperty(exports, "initSQL", { enumerable: true, get: function () { return wasm_loader_1.initSQL; } });
-Object.defineProperty(exports, "getWasm", { enumerable: true, get: function () { return wasm_loader_1.getWasm; } });
-Object.defineProperty(exports, "isWasmInitialized", { enumerable: true, get: function () { return wasm_loader_1.isInitialized; } });
-Object.defineProperty(exports, "resetWasm", { enumerable: true, get: function () { return wasm_loader_1.resetWasm; } });
-// HNSW indexing for high-performance search
-var hnsw_1 = require("./index/hnsw");
-Object.defineProperty(exports, "HNSWIndex", { enumerable: true, get: function () { return hnsw_1.HNSWIndex; } });
-Object.defineProperty(exports, "DEFAULT_HNSW_CONFIG", { enumerable: true, get: function () { return hnsw_1.DEFAULT_HNSW_CONFIG; } });
-var hnsw_optimized_1 = require("./index/hnsw-optimized");
-Object.defineProperty(exports, "OptimizedHNSWIndex", { enumerable: true, get: function () { return hnsw_optimized_1.OptimizedHNSWIndex; } });
-// Query caching for 50-100x speedup on repeated queries
-var query_cache_1 = require("./cache/query-cache");
-Object.defineProperty(exports, "QueryCache", { enumerable: true, get: function () { return query_cache_1.QueryCache; } });
-// Query builder for fluent, type-safe queries
-var query_builder_1 = require("./query/query-builder");
-Object.defineProperty(exports, "VectorQueryBuilder", { enumerable: true, get: function () { return query_builder_1.VectorQueryBuilder; } });
-// Vector quantization for 4-32x compression
-var product_quantization_1 = require("./quantization/product-quantization");
-Object.defineProperty(exports, "ProductQuantizer", { enumerable: true, get: function () { return product_quantization_1.ProductQuantizer; } });
-// Scalar quantization for 4-16x compression with 85-95% accuracy (RECOMMENDED)
-var scalar_quantization_1 = require("./quantization/scalar-quantization");
-Object.defineProperty(exports, "ScalarQuantizer", { enumerable: true, get: function () { return scalar_quantization_1.ScalarQuantizer; } });
-// Optimized quantization with accuracy profiles
-var optimized_pq_1 = require("./quantization/optimized-pq");
-Object.defineProperty(exports, "ImprovedProductQuantizer", { enumerable: true, get: function () { return optimized_pq_1.ImprovedProductQuantizer; } });
-Object.defineProperty(exports, "QuantizationProfiles", { enumerable: true, get: function () { return optimized_pq_1.QuantizationProfiles; } });
-Object.defineProperty(exports, "QuantizationUtils", { enumerable: true, get: function () { return optimized_pq_1.QuantizationUtils; } });
-// Binary quantization for 256x compression and 32x faster search
-var binary_quantization_1 = require("./quantization/binary-quantization");
-Object.defineProperty(exports, "BinaryQuantizer", { enumerable: true, get: function () { return binary_quantization_1.BinaryQuantizer; } });
-Object.defineProperty(exports, "createBinaryQuantizer", { enumerable: true, get: function () { return binary_quantization_1.createBinaryQuantizer; } });
-/**
- * Convenience function to create a vector database (browser version)
- * Always uses WASM backend in browser
- */
-async function createVectorDB(config) {
-    const browserConfig = {
-        ...config,
-        backend: backend_interface_1.BackendType.WASM, // Force WASM in browser
-    };
-    const db = new vector_db_1.SQLiteVectorDB(browserConfig);
-    await db.initializeAsync();
-    return db;
-}
-// Default export for convenience
-exports.default = {
-    SQLiteVectorDB: vector_db_1.SQLiteVectorDB,
-    createVectorDB,
-    BackendType: backend_interface_1.BackendType,
-    initWasm: wasm_loader_1.initWasm,
-};
-//# sourceMappingURL=index.browser.js.map

package/dist/index.browser.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.browser.js","sourceRoot":"","sources":["../src/index.browser.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAmFH,wCAUC;AA3FD,6CAA6C;AAC7C,gDAAkD;AAMzC,+FANA,0BAAc,OAMA;AALvB,sDAAkD;AAMzC,4FANA,0BAAW,OAMA;AALpB,gEAA8F;AAMrF,4FANA,+BAAW,OAMA;AALpB,+CAAqF;AAsE5E,yFAtEA,sBAAQ,OAsEA;AAAE,wFAtEA,qBAAO,OAsEA;AAAE,wFAtEA,qBAAO,OAsEA;AACT,kGAvEW,2BAAa,OAuEP;AADN,0FAtEe,uBAAS,OAsEf;AA9D9C,4CAA4C;AAC5C,qCAA8D;AAArD,iGAAA,SAAS,OAAA;AAAE,2GAAA,mBAAmB,OAAA;AACvC,yDAA4D;AAAnD,oHAAA,kBAAkB,OAAA;AAG3B,wDAAwD;AACxD,mDAAiD;AAAxC,yGAAA,UAAU,OAAA;AAGnB,8CAA8C;AAC9C,uDAA2D;AAAlD,mHAAA,kBAAkB,OAAA;AAG3B,4CAA4C;AAC5C,4EAAuE;AAA9D,wHAAA,gBAAgB,OAAA;AAGzB,+EAA+E;AAC/E,0EAAqE;AAA5D,sHAAA,eAAe,OAAA;AAOxB,gDAAgD;AAChD,4DAIqC;AAHnC,wHAAA,wBAAwB,OAAA;AACxB,oHAAA,oBAAoB,OAAA;AACpB,iHAAA,iBAAiB,OAAA;AAInB,iEAAiE;AACjE,0EAG4C;AAF1C,sHAAA,eAAe,OAAA;AACf,4HAAA,qBAAqB,OAAA;AA6BvB;;;GAGG;AACI,KAAK,UAAU,cAAc,CAAC,MAA+B;IAClE,MAAM,aAAa,GAAG;QACpB,GAAG,MAAM;QACT,OAAO,EAAE,+BAAW,CAAC,IAAI,EAAE,wBAAwB;KACpD,CAAC;IAEF,MAAM,EAAE,GAAG,IAAI,0BAAc,CAAC,aAAa,CAAC,CAAC;IAC7C,MAAM,EAAE,CAAC,eAAe,EAAE,CAAC;IAE3B,OAAO,EAAE,CAAC;AACZ,CAAC;AAED,iCAAiC;AACjC,kBAAe;IACb,cAAc,EAAd,0BAAc;IACd,cAAc;IACd,WAAW,EAAX,+BAAW;IACX,QAAQ,EAAR,sBAAQ;CACT,CAAC"}