agentdb 2.0.0-alpha.2.14 → 2.0.0-alpha.2.15

package/dist/agentdb.browser.js

@@ -0,0 +1,1492 @@
+/*! AgentDB Browser Bundle v2.0.0-alpha.2.15 | MIT License | https://agentdb.ruv.io */
+
+// src/browser/ProductQuantization.ts
+var ProductQuantization = class {
+  config;
+  codebook = null;
+  trained = false;
+  constructor(config) {
+    this.config = {
+      dimension: config.dimension,
+      numSubvectors: config.numSubvectors,
+      numCentroids: config.numCentroids,
+      maxIterations: config.maxIterations || 50,
+      convergenceThreshold: config.convergenceThreshold || 1e-4
+    };
+    if (this.config.dimension % this.config.numSubvectors !== 0) {
+      throw new Error(`Dimension ${this.config.dimension} must be divisible by numSubvectors ${this.config.numSubvectors}`);
+    }
+  }
+  /**
+   * Train codebook using k-means on training vectors
+   */
+  async train(vectors) {
+    if (vectors.length === 0) {
+      throw new Error("Training requires at least one vector");
+    }
+    const subvectorDim = this.config.dimension / this.config.numSubvectors;
+    const centroids = [];
+    console.log(`[PQ] Training ${this.config.numSubvectors} subvectors with ${this.config.numCentroids} centroids each...`);
+    for (let s = 0; s < this.config.numSubvectors; s++) {
+      const startDim = s * subvectorDim;
+      const endDim = startDim + subvectorDim;
+      const subvectors = vectors.map((v) => v.slice(startDim, endDim));
+      const subCentroids = await this.kMeans(subvectors, this.config.numCentroids);
+      centroids.push(...subCentroids);
+      if ((s + 1) % 4 === 0 || s === this.config.numSubvectors - 1) {
+        console.log(`[PQ] Trained ${s + 1}/${this.config.numSubvectors} subvectors`);
+      }
+    }
+    this.codebook = {
+      subvectorDim,
+      numSubvectors: this.config.numSubvectors,
+      numCentroids: this.config.numCentroids,
+      centroids
+    };
+    this.trained = true;
+    console.log("[PQ] Training complete");
+  }
+  /**
+   * K-means clustering for centroids
+   */
+  async kMeans(vectors, k) {
+    const dim = vectors[0].length;
+    const n = vectors.length;
+    const centroids = this.kMeansPlusPlus(vectors, k);
+    const assignments = new Uint32Array(n);
+    let prevInertia = Infinity;
+    for (let iter = 0; iter < this.config.maxIterations; iter++) {
+      let inertia = 0;
+      for (let i = 0; i < n; i++) {
+        let minDist = Infinity;
+        let minIdx = 0;
+        for (let j = 0; j < k; j++) {
+          const dist = this.squaredDistance(vectors[i], centroids[j]);
+          if (dist < minDist) {
+            minDist = dist;
+            minIdx = j;
+          }
+        }
+        assignments[i] = minIdx;
+        inertia += minDist;
+      }
+      if (Math.abs(prevInertia - inertia) < this.config.convergenceThreshold) {
+        break;
+      }
+      prevInertia = inertia;
+      const counts = new Uint32Array(k);
+      const sums = Array.from({ length: k }, () => new Float32Array(dim));
+      for (let i = 0; i < n; i++) {
+        const cluster = assignments[i];
+        counts[cluster]++;
+        for (let d = 0; d < dim; d++) {
+          sums[cluster][d] += vectors[i][d];
+        }
+      }
+      for (let j = 0; j < k; j++) {
+        if (counts[j] > 0) {
+          for (let d = 0; d < dim; d++) {
+            centroids[j][d] = sums[j][d] / counts[j];
+          }
+        }
+      }
+    }
+    return centroids;
+  }
+  /**
+   * K-means++ initialization for better centroid selection
+   */
+  kMeansPlusPlus(vectors, k) {
+    const n = vectors.length;
+    const dim = vectors[0].length;
+    const centroids = [];
+    const firstIdx = Math.floor(Math.random() * n);
+    centroids.push(new Float32Array(vectors[firstIdx]));
+    for (let i = 1; i < k; i++) {
+      const distances = new Float32Array(n);
+      let sumDistances = 0;
+      for (let j = 0; j < n; j++) {
+        let minDist = Infinity;
+        for (const centroid of centroids) {
+          const dist = this.squaredDistance(vectors[j], centroid);
+          minDist = Math.min(minDist, dist);
+        }
+        distances[j] = minDist;
+        sumDistances += minDist;
+      }
+      let r = Math.random() * sumDistances;
+      for (let j = 0; j < n; j++) {
+        r -= distances[j];
+        if (r <= 0) {
+          centroids.push(new Float32Array(vectors[j]));
+          break;
+        }
+      }
+    }
+    return centroids;
+  }
+  /**
+   * Compress a vector using trained codebook
+   */
+  compress(vector) {
+    if (!this.trained || !this.codebook) {
+      throw new Error("Codebook must be trained before compression");
+    }
+    const codes = new Uint8Array(this.config.numSubvectors);
+    const subvectorDim = this.codebook.subvectorDim;
+    let norm = 0;
+    for (let i = 0; i < vector.length; i++) {
+      norm += vector[i] * vector[i];
+    }
+    norm = Math.sqrt(norm);
+    for (let s = 0; s < this.config.numSubvectors; s++) {
+      const startDim = s * subvectorDim;
+      const subvector = vector.slice(startDim, startDim + subvectorDim);
+      let minDist = Infinity;
+      let minIdx = 0;
+      const centroidOffset = s * this.config.numCentroids;
+      for (let c = 0; c < this.config.numCentroids; c++) {
+        const centroid = this.codebook.centroids[centroidOffset + c];
+        const dist = this.squaredDistance(subvector, centroid);
+        if (dist < minDist) {
+          minDist = dist;
+          minIdx = c;
+        }
+      }
+      codes[s] = minIdx;
+    }
+    return { codes, norm };
+  }
+  /**
+   * Decompress a vector (approximate reconstruction)
+   */
+  decompress(compressed) {
+    if (!this.codebook) {
+      throw new Error("Codebook not available");
+    }
+    const vector = new Float32Array(this.config.dimension);
+    const subvectorDim = this.codebook.subvectorDim;
+    for (let s = 0; s < this.config.numSubvectors; s++) {
+      const code = compressed.codes[s];
+      const centroidOffset = s * this.config.numCentroids;
+      const centroid = this.codebook.centroids[centroidOffset + code];
+      const startDim = s * subvectorDim;
+      for (let d = 0; d < subvectorDim; d++) {
+        vector[startDim + d] = centroid[d];
+      }
+    }
+    return vector;
+  }
+  /**
+   * Asymmetric Distance Computation (ADC)
+   * Computes distance from query vector to compressed vector
+   */
+  asymmetricDistance(query, compressed) {
+    if (!this.codebook) {
+      throw new Error("Codebook not available");
+    }
+    let distance = 0;
+    const subvectorDim = this.codebook.subvectorDim;
+    for (let s = 0; s < this.config.numSubvectors; s++) {
+      const code = compressed.codes[s];
+      const centroidOffset = s * this.config.numCentroids;
+      const centroid = this.codebook.centroids[centroidOffset + code];
+      const startDim = s * subvectorDim;
+      const querySubvector = query.slice(startDim, startDim + subvectorDim);
+      distance += this.squaredDistance(querySubvector, centroid);
+    }
+    return Math.sqrt(distance);
+  }
+  /**
+   * Batch compression for multiple vectors
+   */
+  batchCompress(vectors) {
+    return vectors.map((v) => this.compress(v));
+  }
+  /**
+   * Get memory savings
+   */
+  getCompressionRatio() {
+    const originalBytes = this.config.dimension * 4;
+    const compressedBytes = this.config.numSubvectors + 4;
+    return originalBytes / compressedBytes;
+  }
+  /**
+   * Export codebook for persistence
+   */
+  exportCodebook() {
+    if (!this.codebook) {
+      throw new Error("No codebook to export");
+    }
+    return JSON.stringify({
+      config: this.config,
+      codebook: {
+        subvectorDim: this.codebook.subvectorDim,
+        numSubvectors: this.codebook.numSubvectors,
+        numCentroids: this.codebook.numCentroids,
+        centroids: this.codebook.centroids.map((c) => Array.from(c))
+      }
+    });
+  }
+  /**
+   * Import codebook
+   */
+  importCodebook(json) {
+    const data = JSON.parse(json);
+    this.config = data.config;
+    this.codebook = {
+      subvectorDim: data.codebook.subvectorDim,
+      numSubvectors: data.codebook.numSubvectors,
+      numCentroids: data.codebook.numCentroids,
+      centroids: data.codebook.centroids.map((c) => new Float32Array(c))
+    };
+    this.trained = true;
+  }
+  /**
+   * Utility: Squared Euclidean distance
+   */
+  squaredDistance(a, b) {
+    let sum = 0;
+    for (let i = 0; i < a.length; i++) {
+      const diff = a[i] - b[i];
+      sum += diff * diff;
+    }
+    return sum;
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    const compressionRatio = this.getCompressionRatio();
+    const memoryPerVector = this.config.numSubvectors + 4;
+    const codebookSize = this.codebook ? this.config.numSubvectors * this.config.numCentroids * (this.config.dimension / this.config.numSubvectors) * 4 : 0;
+    return {
+      trained: this.trained,
+      compressionRatio,
+      memoryPerVector,
+      codebookSize
+    };
+  }
+};
+function createPQ8(dimension) {
+  return new ProductQuantization({
+    dimension,
+    numSubvectors: 8,
+    numCentroids: 256,
+    maxIterations: 50
+  });
+}
+function createPQ16(dimension) {
+  return new ProductQuantization({
+    dimension,
+    numSubvectors: 16,
+    numCentroids: 256,
+    maxIterations: 50
+  });
+}
+function createPQ32(dimension) {
+  return new ProductQuantization({
+    dimension,
+    numSubvectors: 32,
+    numCentroids: 256,
+    maxIterations: 50
+  });
+}
+
+// src/browser/HNSWIndex.ts
+var MinHeap = class {
+  items = [];
+  push(item, priority) {
+    this.items.push({ item, priority });
+    this.bubbleUp(this.items.length - 1);
+  }
+  pop() {
+    if (this.items.length === 0) return void 0;
+    const result = this.items[0].item;
+    const last = this.items.pop();
+    if (this.items.length > 0) {
+      this.items[0] = last;
+      this.bubbleDown(0);
+    }
+    return result;
+  }
+  peek() {
+    var _a;
+    return (_a = this.items[0]) == null ? void 0 : _a.item;
+  }
+  size() {
+    return this.items.length;
+  }
+  bubbleUp(index) {
+    while (index > 0) {
+      const parentIndex = Math.floor((index - 1) / 2);
+      if (this.items[index].priority >= this.items[parentIndex].priority) break;
+      [this.items[index], this.items[parentIndex]] = [this.items[parentIndex], this.items[index]];
+      index = parentIndex;
+    }
+  }
+  bubbleDown(index) {
+    while (true) {
+      const leftChild = 2 * index + 1;
+      const rightChild = 2 * index + 2;
+      let smallest = index;
+      if (leftChild < this.items.length && this.items[leftChild].priority < this.items[smallest].priority) {
+        smallest = leftChild;
+      }
+      if (rightChild < this.items.length && this.items[rightChild].priority < this.items[smallest].priority) {
+        smallest = rightChild;
+      }
+      if (smallest === index) break;
+      [this.items[index], this.items[smallest]] = [this.items[smallest], this.items[index]];
+      index = smallest;
+    }
+  }
+};
+var HNSWIndex = class {
+  config;
+  nodes = /* @__PURE__ */ new Map();
+  entryPoint = null;
+  currentId = 0;
+  ml;
+  constructor(config = {}) {
+    this.config = {
+      dimension: config.dimension || 384,
+      M: config.M || 16,
+      efConstruction: config.efConstruction || 200,
+      efSearch: config.efSearch || 50,
+      ml: config.ml || 1 / Math.log(2),
+      maxLayers: config.maxLayers || 16,
+      distanceFunction: config.distanceFunction || "cosine"
+    };
+    this.ml = this.config.ml;
+  }
+  /**
+   * Add vector to index
+   */
+  add(vector, id) {
+    const nodeId = id !== void 0 ? id : this.currentId++;
+    const level = this.randomLevel();
+    const node = {
+      id: nodeId,
+      vector,
+      level,
+      connections: /* @__PURE__ */ new Map()
+    };
+    for (let l = 0; l <= level; l++) {
+      node.connections.set(l, []);
+    }
+    if (this.entryPoint === null) {
+      this.entryPoint = nodeId;
+      this.nodes.set(nodeId, node);
+      return nodeId;
+    }
+    const ep = this.entryPoint;
+    let nearest = ep;
+    for (let lc = this.nodes.get(ep).level; lc > level; lc--) {
+      nearest = this.searchLayer(vector, nearest, 1, lc)[0];
+    }
+    for (let lc = Math.min(level, this.nodes.get(ep).level); lc >= 0; lc--) {
+      const candidates = this.searchLayer(vector, nearest, this.config.efConstruction, lc);
+      const M = lc === 0 ? this.config.M * 2 : this.config.M;
+      const neighbors = this.selectNeighbors(vector, candidates, M);
+      for (const neighbor of neighbors) {
+        this.connect(nodeId, neighbor, lc);
+        this.connect(neighbor, nodeId, lc);
+        const neighborNode = this.nodes.get(neighbor);
+        const neighborConnections = neighborNode.connections.get(lc);
+        if (neighborConnections.length > M) {
+          const newNeighbors = this.selectNeighbors(
+            neighborNode.vector,
+            neighborConnections,
+            M
+          );
+          neighborNode.connections.set(lc, newNeighbors);
+        }
+      }
+      nearest = candidates[0];
+    }
+    if (level > this.nodes.get(this.entryPoint).level) {
+      this.entryPoint = nodeId;
+    }
+    this.nodes.set(nodeId, node);
+    return nodeId;
+  }
+  /**
+   * Search for k nearest neighbors
+   */
+  search(query, k, ef) {
+    if (this.entryPoint === null) return [];
+    ef = ef || Math.max(this.config.efSearch, k);
+    let ep = this.entryPoint;
+    let nearest = ep;
+    for (let lc = this.nodes.get(ep).level; lc > 0; lc--) {
+      nearest = this.searchLayer(query, nearest, 1, lc)[0];
+    }
+    const candidates = this.searchLayer(query, nearest, ef, 0);
+    return candidates.slice(0, k).map((id) => ({
+      id,
+      distance: this.distance(query, this.nodes.get(id).vector),
+      vector: this.nodes.get(id).vector
+    }));
+  }
+  /**
+   * Search at specific layer
+   */
+  searchLayer(query, ep, ef, layer) {
+    const visited = /* @__PURE__ */ new Set();
+    const candidates = new MinHeap();
+    const w = new MinHeap();
+    const dist = this.distance(query, this.nodes.get(ep).vector);
+    candidates.push(ep, dist);
+    w.push(ep, -dist);
+    visited.add(ep);
+    while (candidates.size() > 0) {
+      const c = candidates.pop();
+      const fDist = -w.peek();
+      const cDist = this.distance(query, this.nodes.get(c).vector);
+      if (cDist > fDist) break;
+      const neighbors = this.nodes.get(c).connections.get(layer) || [];
+      for (const e of neighbors) {
+        if (visited.has(e)) continue;
+        visited.add(e);
+        const eDist = this.distance(query, this.nodes.get(e).vector);
+        const fDist2 = -w.peek();
+        if (eDist < fDist2 || w.size() < ef) {
+          candidates.push(e, eDist);
+          w.push(e, -eDist);
+          if (w.size() > ef) {
+            w.pop();
+          }
+        }
+      }
+    }
+    const result = [];
+    while (w.size() > 0) {
+      result.unshift(w.pop());
+    }
+    return result;
+  }
+  /**
+   * Select best neighbors using heuristic
+   */
+  selectNeighbors(base, candidates, M) {
+    if (candidates.length <= M) return candidates;
+    const sorted = candidates.map((id) => ({
+      id,
+      distance: this.distance(base, this.nodes.get(id).vector)
+    })).sort((a, b) => a.distance - b.distance);
+    return sorted.slice(0, M).map((x) => x.id);
+  }
+  /**
+   * Connect two nodes at layer
+   */
+  connect(from, to, layer) {
+    const node = this.nodes.get(from);
+    const connections = node.connections.get(layer);
+    if (!connections.includes(to)) {
+      connections.push(to);
+    }
+  }
+  /**
+   * Random level assignment
+   */
+  randomLevel() {
+    let level = 0;
+    while (Math.random() < this.ml && level < this.config.maxLayers - 1) {
+      level++;
+    }
+    return level;
+  }
+  /**
+   * Distance function
+   */
+  distance(a, b) {
+    switch (this.config.distanceFunction) {
+      case "cosine":
+        return 1 - this.cosineSimilarity(a, b);
+      case "euclidean":
+        return this.euclideanDistance(a, b);
+      case "manhattan":
+        return this.manhattanDistance(a, b);
+      default:
+        return 1 - this.cosineSimilarity(a, b);
+    }
+  }
+  cosineSimilarity(a, b) {
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+  }
+  euclideanDistance(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);
+  }
+  manhattanDistance(a, b) {
+    let sum = 0;
+    for (let i = 0; i < a.length; i++) {
+      sum += Math.abs(a[i] - b[i]);
+    }
+    return sum;
+  }
+  /**
+   * Get index statistics
+   */
+  getStats() {
+    if (this.nodes.size === 0) {
+      return {
+        numNodes: 0,
+        numLayers: 0,
+        avgConnections: 0,
+        entryPointLevel: 0,
+        memoryBytes: 0
+      };
+    }
+    const maxLevel = Math.max(...Array.from(this.nodes.values()).map((n) => n.level));
+    let totalConnections = 0;
+    for (const node of this.nodes.values()) {
+      for (const connections of node.connections.values()) {
+        totalConnections += connections.length;
+      }
+    }
+    const avgConnections = totalConnections / this.nodes.size;
+    const vectorBytes = this.config.dimension * 4;
+    const connectionBytes = avgConnections * 4;
+    const metadataBytes = 100;
+    const memoryBytes = this.nodes.size * (vectorBytes + connectionBytes + metadataBytes);
+    return {
+      numNodes: this.nodes.size,
+      numLayers: maxLevel + 1,
+      avgConnections,
+      entryPointLevel: this.entryPoint ? this.nodes.get(this.entryPoint).level : 0,
+      memoryBytes
+    };
+  }
+  /**
+   * Export index for persistence
+   */
+  export() {
+    const data = {
+      config: this.config,
+      entryPoint: this.entryPoint,
+      currentId: this.currentId,
+      nodes: Array.from(this.nodes.entries()).map(([id, node]) => ({
+        id,
+        vector: Array.from(node.vector),
+        level: node.level,
+        connections: Array.from(node.connections.entries())
+      }))
+    };
+    return JSON.stringify(data);
+  }
+  /**
+   * Import index from JSON
+   */
+  import(json) {
+    const data = JSON.parse(json);
+    this.config = data.config;
+    this.entryPoint = data.entryPoint;
+    this.currentId = data.currentId;
+    this.nodes.clear();
+    for (const nodeData of data.nodes) {
+      const node = {
+        id: nodeData.id,
+        vector: new Float32Array(nodeData.vector),
+        level: nodeData.level,
+        connections: new Map(nodeData.connections)
+      };
+      this.nodes.set(nodeData.id, node);
+    }
+  }
+  /**
+   * Clear index
+   */
+  clear() {
+    this.nodes.clear();
+    this.entryPoint = null;
+    this.currentId = 0;
+  }
+  /**
+   * Get number of nodes
+   */
+  size() {
+    return this.nodes.size;
+  }
+};
+function createHNSW(dimension) {
+  return new HNSWIndex({
+    dimension,
+    M: 16,
+    efConstruction: 200,
+    efSearch: 50
+  });
+}
+function createFastHNSW(dimension) {
+  return new HNSWIndex({
+    dimension,
+    M: 8,
+    efConstruction: 100,
+    efSearch: 30
+  });
+}
+function createAccurateHNSW(dimension) {
+  return new HNSWIndex({
+    dimension,
+    M: 32,
+    efConstruction: 400,
+    efSearch: 100
+  });
+}
+
+// src/browser/AdvancedFeatures.ts
+var GraphNeuralNetwork = class {
+  config;
+  nodes = /* @__PURE__ */ new Map();
+  edges = [];
+  attentionWeights = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.config = {
+      hiddenDim: config.hiddenDim || 64,
+      numHeads: config.numHeads || 4,
+      dropout: config.dropout || 0.1,
+      learningRate: config.learningRate || 0.01,
+      attentionType: config.attentionType || "gat"
+    };
+  }
+  /**
+   * Add node to graph
+   */
+  addNode(id, features) {
+    this.nodes.set(id, {
+      id,
+      features,
+      neighbors: []
+    });
+  }
+  /**
+   * Add edge to graph
+   */
+  addEdge(from, to, weight = 1) {
+    this.edges.push({ from, to, weight });
+    const fromNode = this.nodes.get(from);
+    const toNode = this.nodes.get(to);
+    if (fromNode && !fromNode.neighbors.includes(to)) {
+      fromNode.neighbors.push(to);
+    }
+    if (toNode && !toNode.neighbors.includes(from)) {
+      toNode.neighbors.push(from);
+    }
+  }
+  /**
+   * Graph Attention Network (GAT) message passing
+   */
+  graphAttention(nodeId) {
+    const node = this.nodes.get(nodeId);
+    if (!node) throw new Error(`Node ${nodeId} not found`);
+    const neighbors = node.neighbors;
+    if (neighbors.length === 0) {
+      return node.features;
+    }
+    const headDim = Math.floor(this.config.hiddenDim / this.config.numHeads);
+    const aggregated = new Float32Array(this.config.hiddenDim);
+    for (let h = 0; h < this.config.numHeads; h++) {
+      let attentionSum = 0;
+      const headOutput = new Float32Array(headDim);
+      for (const neighborId of neighbors) {
+        const neighbor = this.nodes.get(neighborId);
+        const score = this.computeAttentionScore(
+          node.features,
+          neighbor.features,
+          h
+        );
+        attentionSum += score;
+        for (let i = 0; i < headDim && i < neighbor.features.length; i++) {
+          headOutput[i] += score * neighbor.features[i];
+        }
+      }
+      if (attentionSum > 0) {
+        for (let i = 0; i < headDim; i++) {
+          headOutput[i] /= attentionSum;
+        }
+      }
+      const offset = h * headDim;
+      for (let i = 0; i < headDim; i++) {
+        aggregated[offset + i] = headOutput[i];
+      }
+    }
+    for (let i = 0; i < aggregated.length; i++) {
+      aggregated[i] = aggregated[i] > 0 ? aggregated[i] : 0.01 * aggregated[i];
+    }
+    return aggregated;
+  }
+  /**
+   * Compute attention score between two nodes
+   */
+  computeAttentionScore(features1, features2, head) {
+    let score = 0;
+    const len = Math.min(features1.length, features2.length);
+    for (let i = 0; i < len; i++) {
+      score += features1[i] * features2[i];
+    }
+    return Math.exp(score / Math.sqrt(len));
+  }
+  /**
+   * Message passing for all nodes
+   */
+  messagePass() {
+    const newFeatures = /* @__PURE__ */ new Map();
+    for (const [nodeId] of this.nodes) {
+      newFeatures.set(nodeId, this.graphAttention(nodeId));
+    }
+    return newFeatures;
+  }
+  /**
+   * Update node features after message passing
+   */
+  update(newFeatures) {
+    for (const [nodeId, features] of newFeatures) {
+      const node = this.nodes.get(nodeId);
+      if (node) {
+        node.features = features;
+      }
+    }
+  }
+  /**
+   * Compute graph embeddings for query enhancement
+   */
+  computeGraphEmbedding(nodeId, hops = 2) {
+    const features = /* @__PURE__ */ new Map();
+    features.set(nodeId, this.nodes.get(nodeId).features);
+    for (let h = 0; h < hops; h++) {
+      const newFeatures = this.messagePass();
+      this.update(newFeatures);
+    }
+    return this.nodes.get(nodeId).features;
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return {
+      numNodes: this.nodes.size,
+      numEdges: this.edges.length,
+      avgDegree: this.edges.length / Math.max(this.nodes.size, 1),
+      config: this.config
+    };
+  }
+};
+var MaximalMarginalRelevance = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      lambda: config.lambda || 0.7,
+      metric: config.metric || "cosine"
+    };
+  }
+  /**
+   * Rerank results for diversity
+   * @param query Query vector
+   * @param candidates Candidate vectors with scores
+   * @param k Number of results to return
+   * @returns Reranked indices
+   */
+  rerank(query, candidates, k) {
+    if (candidates.length === 0) return [];
+    const selected = [];
+    const remaining = new Set(candidates.map((_, i) => i));
+    let bestIdx = 0;
+    let bestScore = -Infinity;
+    for (let i = 0; i < candidates.length; i++) {
+      if (candidates[i].score > bestScore) {
+        bestScore = candidates[i].score;
+        bestIdx = i;
+      }
+    }
+    selected.push(candidates[bestIdx].id);
+    remaining.delete(bestIdx);
+    while (selected.length < k && remaining.size > 0) {
+      let bestMMR = -Infinity;
+      let bestCandidate = -1;
+      for (const idx of remaining) {
+        const candidate = candidates[idx];
+        const relevance = this.similarity(query, candidate.vector);
+        let maxSimilarity = -Infinity;
+        for (const selectedId of selected) {
+          const selectedCandidate = candidates.find((c) => c.id === selectedId);
+          const sim = this.similarity(candidate.vector, selectedCandidate.vector);
+          maxSimilarity = Math.max(maxSimilarity, sim);
+        }
+        const mmr = this.config.lambda * relevance - (1 - this.config.lambda) * maxSimilarity;
+        if (mmr > bestMMR) {
+          bestMMR = mmr;
+          bestCandidate = idx;
+        }
+      }
+      if (bestCandidate !== -1) {
+        selected.push(candidates[bestCandidate].id);
+        remaining.delete(bestCandidate);
+      } else {
+        break;
+      }
+    }
+    return selected;
+  }
+  /**
+   * Similarity computation
+   */
+  similarity(a, b) {
+    if (this.config.metric === "cosine") {
+      return this.cosineSimilarity(a, b);
+    } else {
+      const dist = this.euclideanDistance(a, b);
+      return 1 / (1 + dist);
+    }
+  }
+  cosineSimilarity(a, b) {
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+  }
+  euclideanDistance(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);
+  }
+  /**
+   * Set lambda (relevance vs diversity trade-off)
+   */
+  setLambda(lambda) {
+    this.config.lambda = Math.max(0, Math.min(1, lambda));
+  }
+};
+var TensorCompression = class {
+  /**
+   * Reduce dimensionality using truncated SVD
+   * @param vectors Array of vectors to compress
+   * @param targetDim Target dimension
+   * @returns Compressed vectors
+   */
+  static compress(vectors, targetDim) {
+    if (vectors.length === 0) return [];
+    const originalDim = vectors[0].length;
+    if (targetDim >= originalDim) return vectors;
+    const matrix = vectors.map((v) => Array.from(v));
+    const mean = this.computeMean(matrix);
+    const centered = matrix.map(
+      (row) => row.map((val, i) => val - mean[i])
+    );
+    const cov = this.computeCovariance(centered);
+    const eigenvectors = this.powerIteration(cov, targetDim);
+    const compressed = centered.map((row) => {
+      const projected = new Float32Array(targetDim);
+      for (let i = 0; i < targetDim; i++) {
+        let sum = 0;
+        for (let j = 0; j < originalDim; j++) {
+          sum += row[j] * eigenvectors[i][j];
+        }
+        projected[i] = sum;
+      }
+      return projected;
+    });
+    return compressed;
+  }
+  /**
+   * Compute mean vector
+   */
+  static computeMean(matrix) {
+    const n = matrix.length;
+    const dim = matrix[0].length;
+    const mean = new Array(dim).fill(0);
+    for (const row of matrix) {
+      for (let i = 0; i < dim; i++) {
+        mean[i] += row[i];
+      }
+    }
+    return mean.map((v) => v / n);
+  }
+  /**
+   * Compute covariance matrix
+   */
+  static computeCovariance(matrix) {
+    const n = matrix.length;
+    const dim = matrix[0].length;
+    const cov = Array.from(
+      { length: dim },
+      () => new Array(dim).fill(0)
+    );
+    for (let i = 0; i < dim; i++) {
+      for (let j = 0; j <= i; j++) {
+        let sum = 0;
+        for (const row of matrix) {
+          sum += row[i] * row[j];
+        }
+        cov[i][j] = cov[j][i] = sum / n;
+      }
+    }
+    return cov;
+  }
+  /**
+   * Power iteration for computing top eigenvectors
+   */
+  static powerIteration(matrix, k, iterations = 100) {
+    const dim = matrix.length;
+    const eigenvectors = [];
+    for (let i = 0; i < k; i++) {
+      let v = new Array(dim).fill(0).map(() => Math.random() - 0.5);
+      for (let iter = 0; iter < iterations; iter++) {
+        const newV = new Array(dim).fill(0);
+        for (let r = 0; r < dim; r++) {
+          for (let c = 0; c < dim; c++) {
+            newV[r] += matrix[r][c] * v[c];
+          }
+        }
+        for (const prev of eigenvectors) {
+          let dot = 0;
+          for (let j = 0; j < dim; j++) {
+            dot += newV[j] * prev[j];
+          }
+          for (let j = 0; j < dim; j++) {
+            newV[j] -= dot * prev[j];
+          }
+        }
+        let norm = 0;
+        for (const val of newV) {
+          norm += val * val;
+        }
+        norm = Math.sqrt(norm);
+        if (norm < 1e-10) break;
+        v = newV.map((val) => val / norm);
+      }
+      eigenvectors.push(v);
+    }
+    return eigenvectors;
+  }
+};
+var BatchProcessor = class {
+  /**
+   * Batch cosine similarity computation
+   */
+  static batchCosineSimilarity(query, vectors) {
+    const similarities = new Float32Array(vectors.length);
+    let queryNorm = 0;
+    for (let i = 0; i < query.length; i++) {
+      queryNorm += query[i] * query[i];
+    }
+    queryNorm = Math.sqrt(queryNorm);
+    for (let v = 0; v < vectors.length; v++) {
+      const vector = vectors[v];
+      let dotProduct = 0;
+      let vectorNorm = 0;
+      for (let i = 0; i < query.length; i++) {
+        dotProduct += query[i] * vector[i];
+        vectorNorm += vector[i] * vector[i];
+      }
+      vectorNorm = Math.sqrt(vectorNorm);
+      similarities[v] = dotProduct / (queryNorm * vectorNorm);
+    }
+    return similarities;
+  }
+  /**
+   * Batch vector normalization
+   */
+  static batchNormalize(vectors) {
+    return vectors.map((v) => {
+      let norm = 0;
+      for (let i = 0; i < v.length; i++) {
+        norm += v[i] * v[i];
+      }
+      norm = Math.sqrt(norm);
+      const normalized = new Float32Array(v.length);
+      for (let i = 0; i < v.length; i++) {
+        normalized[i] = v[i] / norm;
+      }
+      return normalized;
+    });
+  }
+};
+
+// src/browser/AttentionBrowser.ts
+var AttentionBrowser = class {
+  wasmModule = null;
+  loadingState = "idle";
+  loadError = null;
+  config;
+  constructor(config = {}) {
+    this.config = {
+      dimension: 384,
+      numHeads: 4,
+      blockSize: 64,
+      curvature: -1,
+      useWASM: true,
+      ...config
+    };
+  }
+  /**
+   * Get current loading state
+   */
+  getLoadingState() {
+    return this.loadingState;
+  }
+  /**
+   * Get loading error if any
+   */
+  getError() {
+    return this.loadError;
+  }
+  /**
+   * Initialize WASM module (lazy loaded)
+   */
+  async initialize() {
+    if (this.loadingState === "loaded") return;
+    if (this.loadingState === "loading") {
+      while (this.loadingState === "loading") {
+        await new Promise((resolve) => setTimeout(resolve, 50));
+      }
+      return;
+    }
+    this.loadingState = "loading";
+    try {
+      if (!this.config.useWASM) {
+        this.loadingState = "loaded";
+        return;
+      }
+      const wasmLoader = await import("../../dist/agentdb.wasm-loader.js");
+      this.wasmModule = await wasmLoader.initWASM();
+      this.loadingState = "loaded";
+    } catch (error) {
+      this.loadError = error instanceof Error ? error : new Error(String(error));
+      this.loadingState = "error";
+      console.warn("WASM initialization failed, using fallback:", this.loadError.message);
+    }
+  }
+  /**
+   * Flash Attention - Optimized attention mechanism
+   * O(N) memory complexity instead of O(N²)
+   *
+   * @param query - Query vectors
+   * @param keys - Key vectors
+   * @param values - Value vectors
+   * @returns Attention output
+   */
+  async flashAttention(query, keys, values) {
+    var _a;
+    await this.initialize();
+    if ((_a = this.wasmModule) == null ? void 0 : _a.flashAttention) {
+      try {
+        return this.wasmModule.flashAttention(query, keys, values, this.config);
+      } catch (error) {
+        console.warn("WASM flash attention failed, using fallback:", error);
+      }
+    }
+    return this.flashAttentionFallback(query, keys, values);
+  }
+  /**
+   * Hyperbolic Attention - Attention in hyperbolic space
+   * Better for hierarchical relationships
+   *
+   * @param query - Query vector
+   * @param keys - Key vectors
+   * @returns Similarity scores in hyperbolic space
+   */
+  async hyperbolicAttention(query, keys) {
+    var _a;
+    await this.initialize();
+    if ((_a = this.wasmModule) == null ? void 0 : _a.hyperbolicAttention) {
+      try {
+        return this.wasmModule.hyperbolicAttention(query, keys, this.config);
+      } catch (error) {
+        console.warn("WASM hyperbolic attention failed, using fallback:", error);
+      }
+    }
+    return this.hyperbolicAttentionFallback(query, keys);
+  }
+  /**
+   * Memory Consolidation - Cluster and consolidate similar memories
+   *
+   * @param memories - Array of memory vectors
+   * @param config - Consolidation configuration
+   * @returns Consolidated memory clusters
+   */
+  async consolidateMemories(memories, config = {}) {
+    var _a;
+    await this.initialize();
+    const fullConfig = {
+      threshold: 0.8,
+      maxClusters: 10,
+      minClusterSize: 1,
+      ...config
+    };
+    if ((_a = this.wasmModule) == null ? void 0 : _a.memoryConsolidation) {
+      try {
+        return this.wasmModule.memoryConsolidation(memories, fullConfig);
+      } catch (error) {
+        console.warn("WASM memory consolidation failed, using fallback:", error);
+      }
+    }
+    return this.consolidateMemoriesFallback(memories, fullConfig);
+  }
+  /**
+   * Clean up WASM memory
+   */
+  dispose() {
+    this.wasmModule = null;
+    this.loadingState = "idle";
+    this.loadError = null;
+  }
+  // ========================================================================
+  // Fallback Implementations (Pure JavaScript)
+  // ========================================================================
+  flashAttentionFallback(query, keys, values) {
+    const { dimension = 384 } = this.config;
+    const seqLen = keys.length / dimension;
+    const output = new Float32Array(query.length);
+    for (let i = 0; i < query.length; i += dimension) {
+      const q = query.slice(i, i + dimension);
+      let sumWeights = 0;
+      const weights = new Float32Array(seqLen);
+      for (let j = 0; j < seqLen; j++) {
+        const k = keys.slice(j * dimension, (j + 1) * dimension);
+        let dot = 0;
+        for (let d = 0; d < dimension; d++) {
+          dot += q[d] * k[d];
+        }
+        weights[j] = Math.exp(dot / Math.sqrt(dimension));
+        sumWeights += weights[j];
+      }
+      for (let j = 0; j < seqLen; j++) {
+        weights[j] /= sumWeights || 1;
+        const v = values.slice(j * dimension, (j + 1) * dimension);
+        for (let d = 0; d < dimension; d++) {
+          output[i + d] += weights[j] * v[d];
+        }
+      }
+    }
+    return output;
+  }
+  hyperbolicAttentionFallback(query, keys) {
+    const { curvature = -1 } = this.config;
+    const k = Math.abs(curvature);
+    const similarities = new Float32Array(keys.length / query.length);
+    for (let i = 0; i < similarities.length; i++) {
+      const offset = i * query.length;
+      let dotProduct = 0;
+      let normQ = 0;
+      let normK = 0;
+      for (let j = 0; j < query.length; j++) {
+        dotProduct += query[j] * keys[offset + j];
+        normQ += query[j] * query[j];
+        normK += keys[offset + j] * keys[offset + j];
+      }
+      const euclidean = Math.sqrt(normQ + normK - 2 * dotProduct);
+      const poincare = Math.acosh(1 + 2 * k * euclidean * euclidean);
+      similarities[i] = 1 / (1 + poincare);
+    }
+    return similarities;
+  }
+  consolidateMemoriesFallback(memories, config) {
+    const { threshold = 0.8, maxClusters = 10, minClusterSize = 1 } = config;
+    const consolidated = [];
+    const used = /* @__PURE__ */ new Set();
+    for (let i = 0; i < memories.length; i++) {
+      if (used.has(i)) continue;
+      const cluster = [memories[i]];
+      used.add(i);
+      for (let j = i + 1; j < memories.length; j++) {
+        if (used.has(j)) continue;
+        const similarity = this.cosineSimilarity(memories[i], memories[j]);
+        if (similarity > threshold) {
+          cluster.push(memories[j]);
+          used.add(j);
+        }
+      }
+      if (cluster.length >= minClusterSize) {
+        const centroid = new Float32Array(memories[i].length);
+        for (const mem of cluster) {
+          for (let k = 0; k < centroid.length; k++) {
+            centroid[k] += mem[k] / cluster.length;
+          }
+        }
+        let norm = 0;
+        for (let k = 0; k < centroid.length; k++) {
+          norm += centroid[k] * centroid[k];
+        }
+        norm = Math.sqrt(norm);
+        if (norm > 0) {
+          for (let k = 0; k < centroid.length; k++) {
+            centroid[k] /= norm;
+          }
+        }
+        consolidated.push({
+          memory: centroid,
+          count: cluster.length,
+          members: cluster
+        });
+      }
+      if (consolidated.length >= maxClusters) break;
+    }
+    return consolidated;
+  }
+  cosineSimilarity(a, b) {
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dot += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    const denominator = Math.sqrt(normA * normB);
+    return denominator > 0 ? dot / denominator : 0;
+  }
+};
+function createAttention(config) {
+  return new AttentionBrowser(config);
+}
+function createFastAttention() {
+  return new AttentionBrowser({
+    dimension: 256,
+    numHeads: 2,
+    blockSize: 32,
+    useWASM: true
+  });
+}
+function createAccurateAttention() {
+  return new AttentionBrowser({
+    dimension: 768,
+    numHeads: 8,
+    blockSize: 128,
+    useWASM: true
+  });
+}
+
+// src/browser/index.ts
+function detectFeatures() {
+  return {
+    indexedDB: "indexedDB" in globalThis,
+    broadcastChannel: "BroadcastChannel" in globalThis,
+    webWorkers: typeof globalThis.Worker !== "undefined",
+    wasmSIMD: detectWasmSIMD(),
+    sharedArrayBuffer: typeof SharedArrayBuffer !== "undefined"
+  };
+}
+async function detectWasmSIMD() {
+  try {
+    if (typeof globalThis.WebAssembly === "undefined") {
+      return false;
+    }
+    const simdTest = new Uint8Array([
+      0,
+      97,
+      115,
+      109,
+      1,
+      0,
+      0,
+      0,
+      1,
+      5,
+      1,
+      96,
+      0,
+      1,
+      123,
+      3,
+      2,
+      1,
+      0,
+      10,
+      10,
+      1,
+      8,
+      0,
+      253,
+      12,
+      253,
+      12,
+      253,
+      84,
+      11
+    ]);
+    const WA = globalThis.WebAssembly;
+    const module = await WA.instantiate(simdTest);
+    return module instanceof WA.Instance;
+  } catch {
+    return false;
+  }
+}
+var SMALL_DATASET_CONFIG = {
+  pq: { enabled: false },
+  hnsw: { enabled: false },
+  gnn: { enabled: true, numHeads: 2 },
+  mmr: { enabled: true, lambda: 0.7 },
+  svd: { enabled: false }
+};
+var MEDIUM_DATASET_CONFIG = {
+  pq: { enabled: true, subvectors: 8 },
+  hnsw: { enabled: true, M: 16 },
+  gnn: { enabled: true, numHeads: 4 },
+  mmr: { enabled: true, lambda: 0.7 },
+  svd: { enabled: false }
+};
+var LARGE_DATASET_CONFIG = {
+  pq: { enabled: true, subvectors: 16 },
+  hnsw: { enabled: true, M: 32 },
+  gnn: { enabled: true, numHeads: 4 },
+  mmr: { enabled: true, lambda: 0.7 },
+  svd: { enabled: true, targetDim: 128 }
+};
+var MEMORY_OPTIMIZED_CONFIG = {
+  pq: { enabled: true, subvectors: 32 },
+  // 16x compression
+  hnsw: { enabled: true, M: 8 },
+  // Fewer connections
+  gnn: { enabled: false },
+  mmr: { enabled: false },
+  svd: { enabled: true, targetDim: 64 }
+  // Aggressive dimension reduction
+};
+var SPEED_OPTIMIZED_CONFIG = {
+  pq: { enabled: false },
+  // No compression overhead
+  hnsw: { enabled: true, M: 32, efSearch: 100 },
+  // Maximum HNSW quality
+  gnn: { enabled: false },
+  mmr: { enabled: false },
+  svd: { enabled: false }
+};
+var QUALITY_OPTIMIZED_CONFIG = {
+  pq: { enabled: false },
+  // No compression
+  hnsw: { enabled: true, M: 48, efConstruction: 400 },
+  // Highest quality
+  gnn: { enabled: true, numHeads: 8 },
+  // More attention heads
+  mmr: { enabled: true, lambda: 0.8 },
+  // More diversity
+  svd: { enabled: false }
+  // No dimension loss
+};
+var VERSION = {
+  major: 2,
+  minor: 0,
+  patch: 0,
+  prerelease: "alpha.2",
+  features: "advanced",
+  full: "2.0.0-alpha.2+advanced"
+};
+function estimateMemoryUsage(numVectors, dimension, config) {
+  var _a, _b, _c;
+  let vectorBytes = numVectors * dimension * 4;
+  if ((_a = config.pq) == null ? void 0 : _a.enabled) {
+    const subvectors = config.pq.subvectors || 8;
+    vectorBytes = numVectors * (subvectors + 4);
+  }
+  if ((_b = config.svd) == null ? void 0 : _b.enabled) {
+    const targetDim = config.svd.targetDim || dimension / 2;
+    vectorBytes = numVectors * targetDim * 4;
+  }
+  let indexBytes = 0;
+  if ((_c = config.hnsw) == null ? void 0 : _c.enabled) {
+    const M = config.hnsw.M || 16;
+    const avgConnections = M * 1.5;
+    indexBytes = numVectors * avgConnections * 4;
+  }
+  const total = vectorBytes + indexBytes;
+  return {
+    vectors: vectorBytes,
+    index: indexBytes,
+    total,
+    totalMB: total / (1024 * 1024)
+  };
+}
+function recommendConfig(numVectors, dimension) {
+  if (numVectors < 1e3) {
+    return {
+      name: "SMALL_DATASET",
+      config: SMALL_DATASET_CONFIG,
+      reason: "Small dataset, linear search is fast enough"
+    };
+  } else if (numVectors < 1e4) {
+    return {
+      name: "MEDIUM_DATASET",
+      config: MEDIUM_DATASET_CONFIG,
+      reason: "Medium dataset, HNSW + PQ8 recommended"
+    };
+  } else {
+    return {
+      name: "LARGE_DATASET",
+      config: LARGE_DATASET_CONFIG,
+      reason: "Large dataset, aggressive compression + HNSW recommended"
+    };
+  }
+}
+async function benchmarkSearch(searchFn, numQueries = 100, k = 10, dimension = 384) {
+  const times = [];
+  for (let i = 0; i < numQueries; i++) {
+    const query = new Float32Array(dimension);
+    for (let d = 0; d < dimension; d++) {
+      query[d] = Math.random() - 0.5;
+    }
+    const start = performance.now();
+    searchFn(query, k);
+    const end = performance.now();
+    times.push(end - start);
+  }
+  times.sort((a, b) => a - b);
+  return {
+    avgTimeMs: times.reduce((a, b) => a + b, 0) / times.length,
+    minTimeMs: times[0],
+    maxTimeMs: times[times.length - 1],
+    p50Ms: times[Math.floor(times.length * 0.5)],
+    p95Ms: times[Math.floor(times.length * 0.95)],
+    p99Ms: times[Math.floor(times.length * 0.99)]
+  };
+}
+export {
+  AttentionBrowser,
+  BatchProcessor,
+  GraphNeuralNetwork,
+  HNSWIndex,
+  LARGE_DATASET_CONFIG,
+  MEDIUM_DATASET_CONFIG,
+  MEMORY_OPTIMIZED_CONFIG,
+  MaximalMarginalRelevance,
+  ProductQuantization,
+  QUALITY_OPTIMIZED_CONFIG,
+  SMALL_DATASET_CONFIG,
+  SPEED_OPTIMIZED_CONFIG,
+  TensorCompression,
+  VERSION,
+  benchmarkSearch,
+  createAccurateAttention,
+  createAccurateHNSW,
+  createAttention,
+  createFastAttention,
+  createFastHNSW,
+  createHNSW,
+  createPQ16,
+  createPQ32,
+  createPQ8,
+  detectFeatures,
+  estimateMemoryUsage,
+  recommendConfig
+};
+//# sourceMappingURL=agentdb.browser.js.map