agentdb 2.0.0-alpha.2.15 → 2.0.0-alpha.2.16

package/dist/agentdb.browser.js

@@ -1,4 +1,197 @@
-/*! AgentDB Browser Bundle v2.0.0-alpha.2.15 | MIT License | https://agentdb.ruv.io */
+/*! AgentDB Browser Bundle v2.0.0-alpha.2.16 | MIT License | https://agentdb.ruv.io */
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// dist/agentdb.wasm-loader.js
+var agentdb_wasm_loader_exports = {};
+__export(agentdb_wasm_loader_exports, {
+  initWASM: () => initWASM,
+  wasmLoadError: () => wasmLoadError,
+  wasmModule: () => wasmModule
+});
+async function initWASM() {
+  if (wasmModule) return wasmModule;
+  if (wasmLoading) return wasmLoading;
+  wasmLoading = (async () => {
+    try {
+      if (typeof WebAssembly === "undefined") {
+        throw new Error("WebAssembly not supported in this browser");
+      }
+      const simdSupported = await detectWasmSIMD();
+      console.log(`WASM SIMD support: ${simdSupported}`);
+      wasmModule = {
+        flashAttention: createFlashAttentionMock(),
+        hyperbolicAttention: createHyperbolicAttentionMock(),
+        memoryConsolidation: createMemoryConsolidationMock(),
+        simdSupported
+      };
+      console.log("\u2705 WASM attention module loaded");
+      return wasmModule;
+    } catch (error) {
+      wasmLoadError = error;
+      console.warn("\u26A0\uFE0F  WASM loading failed, using fallback:", error.message);
+      wasmModule = {
+        flashAttention: createFlashAttentionMock(),
+        hyperbolicAttention: createHyperbolicAttentionMock(),
+        memoryConsolidation: createMemoryConsolidationMock(),
+        simdSupported: false
+      };
+      return wasmModule;
+    } finally {
+      wasmLoading = null;
+    }
+  })();
+  return wasmLoading;
+}
+async function detectWasmSIMD() {
+  try {
+    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 module = await WebAssembly.instantiate(simdTest);
+    return module instanceof WebAssembly.Instance;
+  } catch {
+    return false;
+  }
+}
+function createFlashAttentionMock() {
+  return (query, keys, values, options = {}) => {
+    const { dim = 384, numHeads = 4, blockSize = 64 } = options;
+    const seqLen = keys.length / dim;
+    const output = new Float32Array(query.length);
+    for (let i = 0; i < query.length; i += dim) {
+      const q = query.slice(i, i + dim);
+      let sumWeights = 0;
+      const weights = new Float32Array(seqLen);
+      for (let j = 0; j < seqLen; j++) {
+        const k = keys.slice(j * dim, (j + 1) * dim);
+        let dot = 0;
+        for (let d = 0; d < dim; d++) {
+          dot += q[d] * k[d];
+        }
+        weights[j] = Math.exp(dot / Math.sqrt(dim));
+        sumWeights += weights[j];
+      }
+      for (let j = 0; j < seqLen; j++) {
+        weights[j] /= sumWeights;
+        const v = values.slice(j * dim, (j + 1) * dim);
+        for (let d = 0; d < dim; d++) {
+          output[i + d] += weights[j] * v[d];
+        }
+      }
+    }
+    return output;
+  };
+}
+function createHyperbolicAttentionMock() {
+  return (query, keys, options = {}) => {
+    const { curvature = -1 } = options;
+    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;
+  };
+}
+function createMemoryConsolidationMock() {
+  return (memories, options = {}) => {
+    const { threshold = 0.8, maxClusters = 10 } = options;
+    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;
+        let dot = 0;
+        let norm1 = 0;
+        let norm2 = 0;
+        for (let k = 0; k < memories[i].length; k++) {
+          dot += memories[i][k] * memories[j][k];
+          norm1 += memories[i][k] * memories[i][k];
+          norm2 += memories[j][k] * memories[j][k];
+        }
+        const similarity = dot / (Math.sqrt(norm1 * norm2) || 1);
+        if (similarity > threshold) {
+          cluster.push(memories[j]);
+          used.add(j);
+        }
+      }
+      const avg = new Float32Array(memories[i].length);
+      for (const mem of cluster) {
+        for (let k = 0; k < avg.length; k++) {
+          avg[k] += mem[k] / cluster.length;
+        }
+      }
+      consolidated.push({
+        memory: avg,
+        count: cluster.size,
+        members: cluster
+      });
+      if (consolidated.length >= maxClusters) break;
+    }
+    return consolidated;
+  };
+}
+var wasmModule, wasmLoading, wasmLoadError;
+var init_agentdb_wasm_loader = __esm({
+  "dist/agentdb.wasm-loader.js"() {
+    "use strict";
+    wasmModule = null;
+    wasmLoading = null;
+    wasmLoadError = null;
+  }
+});
 
 // src/browser/ProductQuantization.ts
 var ProductQuantization = class {
@@ -1068,7 +1261,7 @@ var AttentionBrowser = class {
         this.loadingState = "loaded";
         return;
       }
-      const wasmLoader = await import("../../dist/agentdb.wasm-loader.js");
+      const wasmLoader = await Promise.resolve().then(() => (init_agentdb_wasm_loader(), agentdb_wasm_loader_exports));
       this.wasmModule = await wasmLoader.initWASM();
       this.loadingState = "loaded";
     } catch (error) {
@@ -1283,11 +1476,11 @@ function detectFeatures() {
     indexedDB: "indexedDB" in globalThis,
     broadcastChannel: "BroadcastChannel" in globalThis,
     webWorkers: typeof globalThis.Worker !== "undefined",
-    wasmSIMD: detectWasmSIMD(),
+    wasmSIMD: detectWasmSIMD2(),
     sharedArrayBuffer: typeof SharedArrayBuffer !== "undefined"
   };
 }
-async function detectWasmSIMD() {
+async function detectWasmSIMD2() {
   try {
     if (typeof globalThis.WebAssembly === "undefined") {
       return false;