@ruvector/edge-full 0.1.0

package/graph/ruvector_graph_wasm_bg.wasm.d.ts

@@ -0,0 +1,80 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_asyncqueryexecutor_free: (a: number, b: number) => void;
+export const __wbg_asynctransaction_free: (a: number, b: number) => void;
+export const __wbg_graphdb_free: (a: number, b: number) => void;
+export const __wbg_jsedge_free: (a: number, b: number) => void;
+export const __wbg_jshyperedge_free: (a: number, b: number) => void;
+export const __wbg_jsnode_free: (a: number, b: number) => void;
+export const __wbg_queryresult_free: (a: number, b: number) => void;
+export const __wbg_resultstream_free: (a: number, b: number) => void;
+export const asyncqueryexecutor_batchSize: (a: number) => number;
+export const asyncqueryexecutor_executeInWorker: (a: number, b: number, c: number) => number;
+export const asyncqueryexecutor_executeStreaming: (a: number, b: number, c: number) => number;
+export const asyncqueryexecutor_new: (a: number) => number;
+export const asyncqueryexecutor_set_batchSize: (a: number, b: number) => void;
+export const asynctransaction_addOperation: (a: number, b: number, c: number) => void;
+export const asynctransaction_commit: (a: number) => number;
+export const asynctransaction_isCommitted: (a: number) => number;
+export const asynctransaction_new: () => number;
+export const asynctransaction_operationCount: (a: number) => number;
+export const asynctransaction_rollback: (a: number) => void;
+export const batchoperations_executeBatch: (a: number, b: number, c: number) => number;
+export const batchoperations_new: (a: number) => number;
+export const graphdb_createEdge: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+export const graphdb_createHyperedge: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+export const graphdb_createNode: (a: number, b: number, c: number, d: number, e: number) => void;
+export const graphdb_deleteEdge: (a: number, b: number, c: number) => number;
+export const graphdb_deleteNode: (a: number, b: number, c: number) => number;
+export const graphdb_exportCypher: (a: number, b: number) => void;
+export const graphdb_getEdge: (a: number, b: number, c: number) => number;
+export const graphdb_getHyperedge: (a: number, b: number, c: number) => number;
+export const graphdb_getNode: (a: number, b: number, c: number) => number;
+export const graphdb_importCypher: (a: number, b: number, c: number) => number;
+export const graphdb_new: (a: number, b: number, c: number) => void;
+export const graphdb_query: (a: number, b: number, c: number) => number;
+export const graphdb_stats: (a: number) => number;
+export const jsedge_from: (a: number, b: number) => void;
+export const jsedge_getProperty: (a: number, b: number, c: number) => number;
+export const jsedge_id: (a: number, b: number) => void;
+export const jsedge_properties: (a: number) => number;
+export const jsedge_to: (a: number, b: number) => void;
+export const jsedge_type: (a: number, b: number) => void;
+export const jshyperedge_confidence: (a: number) => number;
+export const jshyperedge_description: (a: number, b: number) => void;
+export const jshyperedge_embedding: (a: number, b: number) => void;
+export const jshyperedge_id: (a: number, b: number) => void;
+export const jshyperedge_nodes: (a: number, b: number) => void;
+export const jshyperedge_order: (a: number) => number;
+export const jshyperedge_properties: (a: number) => number;
+export const jsnode_embedding: (a: number, b: number) => void;
+export const jsnode_getProperty: (a: number, b: number, c: number) => number;
+export const jsnode_hasLabel: (a: number, b: number, c: number) => number;
+export const jsnode_id: (a: number, b: number) => void;
+export const jsnode_labels: (a: number, b: number) => void;
+export const jsnode_properties: (a: number) => number;
+export const queryresult_count: (a: number) => number;
+export const queryresult_data: (a: number) => number;
+export const queryresult_edges: (a: number, b: number) => void;
+export const queryresult_hyperedges: (a: number, b: number) => void;
+export const queryresult_isEmpty: (a: number) => number;
+export const queryresult_nodes: (a: number, b: number) => void;
+export const resultstream_new: (a: number) => number;
+export const resultstream_nextChunk: (a: number) => number;
+export const resultstream_offset: (a: number) => number;
+export const resultstream_reset: (a: number) => void;
+export const version: (a: number) => void;
+export const init: () => void;
+export const batchoperations_maxBatchSize: (a: number) => number;
+export const resultstream_chunkSize: (a: number) => number;
+export const __wbg_batchoperations_free: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_446: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_445: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_774: (a: number, b: number, c: number, d: number) => void;
+export const __wbindgen_export: (a: number, b: number) => number;
+export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export3: (a: number) => void;
+export const __wbindgen_export4: (a: number, b: number, c: number) => void;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_start: () => void;

package/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @ruvector/edge-full - Complete WASM toolkit for edge AI
+ */
+
+// Module namespaces
+export * as edge from './edge/ruvector_edge';
+export * as graph from './graph/ruvector_graph_wasm';
+export * as rvlite from './rvlite/rvlite';
+export * as sona from './sona/ruvector_sona';
+export * as dag from './dag/ruvector_dag_wasm';
+
+// ONNX init function
+export { default as onnxInit } from './onnx/ruvector_onnx_embeddings_wasm';
+
+// Module info interface
+export interface ModuleInfo {
+  name: string;
+  size: string;
+  features: string[];
+}
+
+export interface ModulesMap {
+  edge: ModuleInfo;
+  graph: ModuleInfo;
+  rvlite: ModuleInfo;
+  sona: ModuleInfo;
+  dag: ModuleInfo;
+  onnx: ModuleInfo;
+}
+
+export const modules: ModulesMap;
+
+export interface TotalSize {
+  core: string;
+  withOnnx: string;
+}
+
+export const totalSize: TotalSize;
+
+/**
+ * Initialize all core modules (excludes ONNX due to size)
+ */
+export function initAll(): Promise<{
+  edge: typeof import('./edge/ruvector_edge');
+  graph: typeof import('./graph/ruvector_graph_wasm');
+  rvlite: typeof import('./rvlite/rvlite');
+  sona: typeof import('./sona/ruvector_sona');
+  dag: typeof import('./dag/ruvector_dag_wasm');
+}>;
+
+/**
+ * Initialize only specific modules
+ * @param moduleNames - Array of module names to init
+ */
+export function initModules(moduleNames: Array<'edge' | 'graph' | 'rvlite' | 'sona' | 'dag' | 'onnx'>): Promise<{
+  edge?: typeof import('./edge/ruvector_edge');
+  graph?: typeof import('./graph/ruvector_graph_wasm');
+  rvlite?: typeof import('./rvlite/rvlite');
+  sona?: typeof import('./sona/ruvector_sona');
+  dag?: typeof import('./dag/ruvector_dag_wasm');
+  onnx?: typeof import('./onnx/ruvector_onnx_embeddings_wasm');
+}>;
+
+export const quickStart: string;

package/index.js

@@ -0,0 +1,182 @@
+/**
+ * @ruvector/edge-full - Complete WASM toolkit for edge AI
+ *
+ * This package bundles all RuVector WASM modules for comprehensive
+ * edge computing capabilities:
+ *
+ * - edge: Cryptographic identity, P2P, vector search, neural networks
+ * - graph: Neo4j-style graph database with Cypher queries
+ * - rvlite: SQL/SPARQL/Cypher vector database
+ * - sona: Self-optimizing neural architecture with LoRA
+ * - dag: Directed acyclic graph for workflow orchestration
+ * - onnx: ONNX inference with HuggingFace embedding models
+ *
+ * Each module can be imported separately:
+ *
+ *   import { WasmIdentity, WasmHnswIndex } from '@ruvector/edge-full/edge';
+ *   import { WasmGraphStore } from '@ruvector/edge-full/graph';
+ *   import { Database } from '@ruvector/edge-full/rvlite';
+ *   import { SonaEngine } from '@ruvector/edge-full/sona';
+ *   import { Dag } from '@ruvector/edge-full/dag';
+ *   import { OnnxEmbedder } from '@ruvector/edge-full/onnx';
+ *
+ * Or use the unified init for quick setup:
+ *
+ *   import { initAll, edge, graph, rvlite, sona, dag } from '@ruvector/edge-full';
+ *   await initAll();
+ */
+
+// Re-export all modules for convenience
+export * as edge from './edge/ruvector_edge.js';
+export * as graph from './graph/ruvector_graph_wasm.js';
+export * as rvlite from './rvlite/rvlite.js';
+export * as sona from './sona/ruvector_sona.js';
+export * as dag from './dag/ruvector_dag_wasm.js';
+
+// ONNX is large (7MB), export separately
+export { default as onnxInit } from './onnx/ruvector_onnx_embeddings_wasm.js';
+
+// Module info
+export const modules = {
+  edge: {
+    name: 'RuVector Edge',
+    size: '364KB',
+    features: ['Ed25519 identity', 'AES-256-GCM encryption', 'HNSW vector search',
+               'Raft consensus', 'Neural networks', 'Post-quantum crypto']
+  },
+  graph: {
+    name: 'Graph Database',
+    size: '288KB',
+    features: ['Neo4j-style API', 'Cypher queries', 'Hypergraph support',
+               'Worker threads', 'IndexedDB persistence']
+  },
+  rvlite: {
+    name: 'RVLite Vector DB',
+    size: '260KB',
+    features: ['SQL queries', 'SPARQL queries', 'Cypher queries',
+               'Multi-index', 'Browser/Node/Edge']
+  },
+  sona: {
+    name: 'SONA Neural',
+    size: '238KB',
+    features: ['Two-tier LoRA', 'EWC++', 'ReasoningBank',
+               'Adaptive learning', 'Router optimization']
+  },
+  dag: {
+    name: 'DAG Workflows',
+    size: '132KB',
+    features: ['Workflow orchestration', 'Dependency tracking',
+               'Topological sort', 'Minimal footprint']
+  },
+  onnx: {
+    name: 'ONNX Embeddings',
+    size: '7.1MB',
+    features: ['HuggingFace models', '6 pre-trained models',
+               'Parallel workers', 'SIMD acceleration']
+  }
+};
+
+// Calculate total size
+export const totalSize = {
+  core: '1.28MB', // edge + graph + rvlite + sona + dag
+  withOnnx: '8.4MB' // including ONNX
+};
+
+/**
+ * Initialize all core modules (excludes ONNX due to size)
+ * For ONNX, import and init separately:
+ *   import onnxInit from '@ruvector/edge-full/onnx';
+ *   await onnxInit();
+ */
+export async function initAll() {
+  const { default: edgeInit } = await import('./edge/ruvector_edge.js');
+  const { default: graphInit } = await import('./graph/ruvector_graph_wasm.js');
+  const { default: rvliteInit } = await import('./rvlite/rvlite.js');
+  const { default: sonaInit } = await import('./sona/ruvector_sona.js');
+  const { default: dagInit } = await import('./dag/ruvector_dag_wasm.js');
+
+  await Promise.all([
+    edgeInit(),
+    graphInit(),
+    rvliteInit(),
+    sonaInit(),
+    dagInit()
+  ]);
+
+  return { edge, graph, rvlite, sona, dag };
+}
+
+/**
+ * Initialize only specific modules
+ * @param {string[]} moduleNames - Array of module names to init
+ */
+export async function initModules(moduleNames) {
+  const results = {};
+
+  for (const name of moduleNames) {
+    switch (name) {
+      case 'edge':
+        const { default: edgeInit } = await import('./edge/ruvector_edge.js');
+        await edgeInit();
+        results.edge = await import('./edge/ruvector_edge.js');
+        break;
+      case 'graph':
+        const { default: graphInit } = await import('./graph/ruvector_graph_wasm.js');
+        await graphInit();
+        results.graph = await import('./graph/ruvector_graph_wasm.js');
+        break;
+      case 'rvlite':
+        const { default: rvliteInit } = await import('./rvlite/rvlite.js');
+        await rvliteInit();
+        results.rvlite = await import('./rvlite/rvlite.js');
+        break;
+      case 'sona':
+        const { default: sonaInit } = await import('./sona/ruvector_sona.js');
+        await sonaInit();
+        results.sona = await import('./sona/ruvector_sona.js');
+        break;
+      case 'dag':
+        const { default: dagInit } = await import('./dag/ruvector_dag_wasm.js');
+        await dagInit();
+        results.dag = await import('./dag/ruvector_dag_wasm.js');
+        break;
+      case 'onnx':
+        const { default: onnxInit } = await import('./onnx/ruvector_onnx_embeddings_wasm.js');
+        await onnxInit();
+        results.onnx = await import('./onnx/ruvector_onnx_embeddings_wasm.js');
+        break;
+    }
+  }
+
+  return results;
+}
+
+// Quick start example
+export const quickStart = `
+// Initialize all core modules (1.28MB total)
+import { initAll } from '@ruvector/edge-full';
+
+const { edge, graph, rvlite, sona, dag } from await initAll();
+
+// Create cryptographic identity
+const identity = new edge.WasmIdentity.generate();
+console.log('Agent:', identity.agent_id());
+
+// Build a graph
+const graphStore = new graph.WasmGraphStore();
+graphStore.run_cypher("CREATE (a:Agent {id: 'agent-1'})");
+
+// Vector search with SQL
+const db = new rvlite.Database();
+db.execute("INSERT INTO vectors (embedding) VALUES ([1,2,3])");
+
+// Self-learning neural routing
+const sonaEngine = new sona.SonaEngine();
+sonaEngine.route_request({ task: "analyze" });
+
+// Workflow orchestration
+const workflow = new dag.Dag();
+workflow.add_node("start");
+workflow.add_node("process");
+workflow.add_edge("start", "process");
+`;

package/onnx/ruvector_onnx_embeddings_wasm.d.ts

@@ -0,0 +1,112 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Strategy for pooling token embeddings into a single sentence embedding
+ */
+export enum PoolingStrategy {
+  /**
+   * Average all token embeddings (most common)
+   */
+  Mean = 0,
+  /**
+   * Use only the [CLS] token embedding
+   */
+  Cls = 1,
+  /**
+   * Take the maximum value across all tokens for each dimension
+   */
+  Max = 2,
+  /**
+   * Mean pooling normalized by sqrt of sequence length
+   */
+  MeanSqrtLen = 3,
+  /**
+   * Use the last token embedding (for decoder models)
+   */
+  LastToken = 4,
+}
+
+export class WasmEmbedder {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get maximum sequence length
+   */
+  maxLength(): number;
+  /**
+   * Compute similarity between two texts
+   */
+  similarity(text1: string, text2: string): number;
+  /**
+   * Generate embeddings for multiple texts
+   */
+  embedBatch(texts: string[]): Float32Array;
+  /**
+   * Create embedder with custom configuration
+   */
+  static withConfig(model_bytes: Uint8Array, tokenizer_json: string, config: WasmEmbedderConfig): WasmEmbedder;
+  /**
+   * Create a new embedder from model and tokenizer bytes
+   *
+   * # Arguments
+   * * `model_bytes` - ONNX model file bytes
+   * * `tokenizer_json` - Tokenizer JSON configuration
+   */
+  constructor(model_bytes: Uint8Array, tokenizer_json: string);
+  /**
+   * Get the embedding dimension
+   */
+  dimension(): number;
+  /**
+   * Generate embedding for a single text
+   */
+  embedOne(text: string): Float32Array;
+}
+
+export class WasmEmbedderConfig {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Set pooling strategy (0=Mean, 1=Cls, 2=Max, 3=MeanSqrtLen, 4=LastToken)
+   */
+  setPooling(pooling: number): WasmEmbedderConfig;
+  /**
+   * Set whether to normalize embeddings
+   */
+  setNormalize(normalize: boolean): WasmEmbedderConfig;
+  /**
+   * Set maximum sequence length
+   */
+  setMaxLength(max_length: number): WasmEmbedderConfig;
+  /**
+   * Create a new configuration
+   */
+  constructor();
+}
+
+/**
+ * Compute cosine similarity between two embedding vectors (JS-friendly)
+ */
+export function cosineSimilarity(a: Float32Array, b: Float32Array): number;
+
+/**
+ * Initialize panic hook for better error messages in WASM
+ */
+export function init(): void;
+
+/**
+ * L2 normalize an embedding vector (JS-friendly)
+ */
+export function normalizeL2(embedding: Float32Array): Float32Array;
+
+/**
+ * Check if SIMD is available (for performance info)
+ * Returns true if compiled with WASM SIMD128 support
+ */
+export function simd_available(): boolean;
+
+/**
+ * Get the library version
+ */
+export function version(): string;