@ruvector/graph-node 0.1.15

package/README.md

@@ -0,0 +1,106 @@
+# @ruvector/graph-node
+
+Native Node.js bindings for RuVector Graph Database with hypergraph support, Cypher queries, and persistence. **10x faster than WASM**.
+
+## Features
+
+- **Native Performance**: Direct NAPI-RS bindings - no WASM overhead
+- **Hypergraph Support**: Multi-node relationships with vector embeddings
+- **Cypher Queries**: Neo4j-compatible query language
+- **Persistence**: ACID-compliant storage with redb backend
+- **Vector Similarity Search**: Fast k-NN search on embeddings
+- **Graph Traversal**: k-hop neighbor discovery
+- **Transactions**: Full ACID support with begin/commit/rollback
+- **Batch Operations**: High-throughput bulk inserts (131K+ ops/sec)
+- **Zero-Copy**: Efficient Float32Array handling
+- **TypeScript**: Full type definitions included
+
+## Installation
+
+```bash
+npm install @ruvector/graph-node
+```
+
+## Quick Start
+
+```javascript
+const { GraphDatabase } = require('@ruvector/graph-node');
+
+// Create an in-memory database
+const db = new GraphDatabase({
+  distanceMetric: 'Cosine',
+  dimensions: 384
+});
+
+// Or create a persistent database
+const persistentDb = new GraphDatabase({
+  distanceMetric: 'Cosine',
+  dimensions: 384,
+  storagePath: './my-graph.db'
+});
+
+// Or open an existing database
+const existingDb = GraphDatabase.open('./my-graph.db');
+
+// Create nodes
+await db.createNode({
+  id: 'alice',
+  embedding: new Float32Array([1.0, 0.0, 0.0, /* ... */]),
+  labels: ['Person', 'Employee'],
+  properties: { name: 'Alice', age: '30' }
+});
+
+// Create edges
+await db.createEdge({
+  from: 'alice',
+  to: 'bob',
+  description: 'KNOWS',
+  embedding: new Float32Array([0.5, 0.5, 0.0, /* ... */]),
+  confidence: 0.95
+});
+
+// Create hyperedges (multi-node relationships)
+await db.createHyperedge({
+  nodes: ['alice', 'bob', 'charlie'],
+  description: 'COLLABORATED_ON_PROJECT',
+  embedding: new Float32Array([0.33, 0.33, 0.33, /* ... */]),
+  confidence: 0.85
+});
+
+// Query with Cypher
+const results = await db.query('MATCH (n:Person) RETURN n');
+
+// Vector similarity search
+const similar = await db.searchHyperedges({
+  embedding: new Float32Array([0.3, 0.3, 0.3, /* ... */]),
+  k: 10
+});
+
+// Get statistics
+const stats = await db.stats();
+console.log(\`Nodes: \${stats.totalNodes}, Edges: \${stats.totalEdges}\`);
+```
+
+## Benchmarks
+
+| Operation | Throughput | Latency |
+|-----------|------------|---------|
+| Node Creation | 9.17K ops/sec | 109ms |
+| Batch Node Creation | 131.10K ops/sec | 7.63ms |
+| Edge Creation | 9.30K ops/sec | 107ms |
+| Vector Search (k=10) | 2.35K ops/sec | 42ms |
+| k-hop Traversal | 10.28K ops/sec | 9.73ms |
+
+## Platform Support
+
+| Platform | Architecture | Status |
+|----------|--------------|--------|
+| Linux | x64 (glibc) | Supported |
+| Linux | arm64 (glibc) | Supported |
+| macOS | x64 | Supported |
+| macOS | arm64 (M1/M2) | Supported |
+| Windows | x64 | Supported |
+
+## License
+
+MIT

package/index.d.ts

@@ -0,0 +1,370 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+/** Distance metric for similarity calculation */
+export const enum JsDistanceMetric {
+  Euclidean = 'Euclidean',
+  Cosine = 'Cosine',
+  DotProduct = 'DotProduct',
+  Manhattan = 'Manhattan'
+}
+/** Graph database configuration options */
+export interface JsGraphOptions {
+  /** Distance metric for embeddings */
+  distanceMetric?: JsDistanceMetric
+  /** Vector dimensions */
+  dimensions?: number
+  /** Storage path */
+  storagePath?: string
+}
+/** Node in the graph */
+export interface JsNode {
+  /** Node ID */
+  id: string
+  /** Node embedding */
+  embedding: Float32Array
+  /** Node labels (e.g., ["Person", "Employee"]) */
+  labels?: Array<string>
+  /** Optional properties */
+  properties?: Record<string, string>
+}
+/** Edge between two nodes */
+export interface JsEdge {
+  /** Source node ID */
+  from: string
+  /** Target node ID */
+  to: string
+  /** Edge description/label */
+  description: string
+  /** Edge embedding */
+  embedding: Float32Array
+  /** Confidence score (0.0-1.0) */
+  confidence?: number
+  /** Optional metadata */
+  metadata?: Record<string, string>
+}
+/** Hyperedge connecting multiple nodes */
+export interface JsHyperedge {
+  /** Node IDs connected by this hyperedge */
+  nodes: Array<string>
+  /** Natural language description of the relationship */
+  description: string
+  /** Embedding of the hyperedge description */
+  embedding: Float32Array
+  /** Confidence weight (0.0-1.0) */
+  confidence?: number
+  /** Optional metadata */
+  metadata?: Record<string, string>
+}
+/** Query for searching hyperedges */
+export interface JsHyperedgeQuery {
+  /** Query embedding */
+  embedding: Float32Array
+  /** Number of results to return */
+  k: number
+}
+/** Hyperedge search result */
+export interface JsHyperedgeResult {
+  /** Hyperedge ID */
+  id: string
+  /** Similarity score */
+  score: number
+}
+/** Node result from query (without embedding) */
+export interface JsNodeResult {
+  /** Node ID */
+  id: string
+  /** Node labels */
+  labels: Array<string>
+  /** Node properties */
+  properties: Record<string, string>
+}
+/** Edge result from query */
+export interface JsEdgeResult {
+  /** Edge ID */
+  id: string
+  /** Source node ID */
+  from: string
+  /** Target node ID */
+  to: string
+  /** Edge type/label */
+  edgeType: string
+  /** Edge properties */
+  properties: Record<string, string>
+}
+/** Query result */
+export interface JsQueryResult {
+  /** Nodes returned by the query */
+  nodes: Array<JsNodeResult>
+  /** Edges returned by the query */
+  edges: Array<JsEdgeResult>
+  /** Optional statistics */
+  stats?: JsGraphStats
+}
+/** Graph statistics */
+export interface JsGraphStats {
+  /** Total number of nodes */
+  totalNodes: number
+  /** Total number of edges */
+  totalEdges: number
+  /** Average node degree */
+  avgDegree: number
+}
+/** Batch insert data */
+export interface JsBatchInsert {
+  /** Nodes to insert */
+  nodes: Array<JsNode>
+  /** Edges to insert */
+  edges: Array<JsEdge>
+}
+/** Batch insert result */
+export interface JsBatchResult {
+  /** IDs of inserted nodes */
+  nodeIds: Array<string>
+  /** IDs of inserted edges */
+  edgeIds: Array<string>
+}
+/** Temporal granularity */
+export const enum JsTemporalGranularity {
+  Hourly = 'Hourly',
+  Daily = 'Daily',
+  Monthly = 'Monthly',
+  Yearly = 'Yearly'
+}
+/** Temporal hyperedge */
+export interface JsTemporalHyperedge {
+  /** Base hyperedge */
+  hyperedge: JsHyperedge
+  /** Creation timestamp (Unix epoch seconds) */
+  timestamp: number
+  /** Optional expiration timestamp */
+  expiresAt?: number
+  /** Temporal context */
+  granularity: JsTemporalGranularity
+}
+/** Get the version of the library */
+export declare function version(): string
+/** Test function to verify bindings */
+export declare function hello(): string
+/** Streaming query result iterator */
+export declare class QueryResultStream {
+  /**
+   * Get the next result from the stream
+   *
+   * # Example
+   * ```javascript
+   * const stream = await db.queryStream('MATCH (n) RETURN n');
+   * while (true) {
+   *   const result = await stream.next();
+   *   if (!result) break;
+   *   console.log(result);
+   * }
+   * ```
+   */
+  next(): JsQueryResult | null
+}
+/** Streaming hyperedge result iterator */
+export declare class HyperedgeStream {
+  /**
+   * Get the next hyperedge result
+   *
+   * # Example
+   * ```javascript
+   * const stream = await db.searchHyperedgesStream(query);
+   * for await (const result of stream) {
+   *   console.log(result);
+   * }
+   * ```
+   */
+  next(): JsHyperedgeResult | null
+  /** Collect all remaining results */
+  collect(): Array<JsHyperedgeResult>
+}
+/** Node stream iterator */
+export declare class NodeStream {
+  /** Get the next node */
+  next(): JsNode | null
+  /** Collect all remaining nodes */
+  collect(): Array<JsNode>
+}
+/** Graph database for complex relationship queries */
+export declare class GraphDatabase {
+  /**
+   * Create a new graph database
+   *
+   * # Example
+   * ```javascript
+   * const db = new GraphDatabase({
+   *   distanceMetric: 'Cosine',
+   *   dimensions: 384
+   * });
+   * ```
+   */
+  constructor(options?: JsGraphOptions | undefined | null)
+  /**
+   * Open an existing graph database from disk
+   *
+   * # Example
+   * ```javascript
+   * const db = GraphDatabase.open('./my-graph.db');
+   * ```
+   */
+  static open(path: string): GraphDatabase
+  /**
+   * Check if persistence is enabled
+   *
+   * # Example
+   * ```javascript
+   * if (db.isPersistent()) {
+   *   console.log('Data is being saved to:', db.getStoragePath());
+   * }
+   * ```
+   */
+  isPersistent(): boolean
+  /** Get the storage path (if persisted) */
+  getStoragePath(): string | null
+  /**
+   * Create a node in the graph
+   *
+   * # Example
+   * ```javascript
+   * const nodeId = await db.createNode({
+   *   id: 'node1',
+   *   embedding: new Float32Array([1, 2, 3]),
+   *   properties: { name: 'Alice', age: 30 }
+   * });
+   * ```
+   */
+  createNode(node: JsNode): Promise<string>
+  /**
+   * Create an edge between two nodes
+   *
+   * # Example
+   * ```javascript
+   * const edgeId = await db.createEdge({
+   *   from: 'node1',
+   *   to: 'node2',
+   *   description: 'knows',
+   *   embedding: new Float32Array([0.5, 0.5, 0.5]),
+   *   confidence: 0.95
+   * });
+   * ```
+   */
+  createEdge(edge: JsEdge): Promise<string>
+  /**
+   * Create a hyperedge connecting multiple nodes
+   *
+   * # Example
+   * ```javascript
+   * const hyperedgeId = await db.createHyperedge({
+   *   nodes: ['node1', 'node2', 'node3'],
+   *   description: 'collaborated_on_project',
+   *   embedding: new Float32Array([0.3, 0.6, 0.9]),
+   *   confidence: 0.85,
+   *   metadata: { project: 'AI Research' }
+   * });
+   * ```
+   */
+  createHyperedge(hyperedge: JsHyperedge): Promise<string>
+  /**
+   * Query the graph using Cypher-like syntax
+   *
+   * # Example
+   * ```javascript
+   * const results = await db.query('MATCH (n) RETURN n LIMIT 10');
+   * ```
+   */
+  query(cypher: string): Promise<JsQueryResult>
+  /**
+   * Query the graph synchronously
+   *
+   * # Example
+   * ```javascript
+   * const results = db.querySync('MATCH (n) RETURN n LIMIT 10');
+   * ```
+   */
+  querySync(cypher: string): JsQueryResult
+  /**
+   * Search for similar hyperedges
+   *
+   * # Example
+   * ```javascript
+   * const results = await db.searchHyperedges({
+   *   embedding: new Float32Array([0.5, 0.5, 0.5]),
+   *   k: 10
+   * });
+   * ```
+   */
+  searchHyperedges(query: JsHyperedgeQuery): Promise<Array<JsHyperedgeResult>>
+  /**
+   * Get k-hop neighbors from a starting node
+   *
+   * # Example
+   * ```javascript
+   * const neighbors = await db.kHopNeighbors('node1', 2);
+   * ```
+   */
+  kHopNeighbors(startNode: string, k: number): Promise<Array<string>>
+  /**
+   * Begin a new transaction
+   *
+   * # Example
+   * ```javascript
+   * const txId = await db.begin();
+   * ```
+   */
+  begin(): Promise<string>
+  /**
+   * Commit a transaction
+   *
+   * # Example
+   * ```javascript
+   * await db.commit(txId);
+   * ```
+   */
+  commit(txId: string): Promise<void>
+  /**
+   * Rollback a transaction
+   *
+   * # Example
+   * ```javascript
+   * await db.rollback(txId);
+   * ```
+   */
+  rollback(txId: string): Promise<void>
+  /**
+   * Batch insert nodes and edges
+   *
+   * # Example
+   * ```javascript
+   * await db.batchInsert({
+   *   nodes: [{ id: 'n1', embedding: new Float32Array([1, 2]) }],
+   *   edges: [{ from: 'n1', to: 'n2', description: 'knows' }]
+   * });
+   * ```
+   */
+  batchInsert(batch: JsBatchInsert): Promise<JsBatchResult>
+  /**
+   * Subscribe to graph changes (returns a change stream)
+   *
+   * # Example
+   * ```javascript
+   * const unsubscribe = db.subscribe((change) => {
+   *   console.log('Graph changed:', change);
+   * });
+   * ```
+   */
+  subscribe(callback: (...args: any[]) => any): void
+  /**
+   * Get graph statistics
+   *
+   * # Example
+   * ```javascript
+   * const stats = await db.stats();
+   * console.log(`Nodes: ${stats.totalNodes}, Edges: ${stats.totalEdges}`);
+   * ```
+   */
+  stats(): Promise<JsGraphStats>
+}

package/index.js

@@ -0,0 +1,322 @@
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+
+/* auto-generated by NAPI-RS */
+
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      const lddPath = require('child_process').execSync('which ldd').toString().trim()
+      return readFileSync(lddPath, 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'index.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.android-arm64.node')
+          } else {
+            nativeBinding = require('@ruvector/graph-node-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'index.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('@ruvector/graph-node-android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, 'index.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('@ruvector/graph-node-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'index.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('@ruvector/graph-node-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'index.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('@ruvector/graph-node-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'index.darwin-universal.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./index.darwin-universal.node')
+      } else {
+        nativeBinding = require('@ruvector/graph-node-darwin-universal')
+      }
+      break
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'index.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.darwin-x64.node')
+          } else {
+            nativeBinding = require('@ruvector/graph-node-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'index.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.darwin-arm64.node')
+          } else {
+            nativeBinding = require('@ruvector/graph-node-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'index.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./index.freebsd-x64.node')
+      } else {
+        nativeBinding = require('@ruvector/graph-node-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('@ruvector/graph-node-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('@ruvector/graph-node-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('@ruvector/graph-node-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('@ruvector/graph-node-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-arm-musleabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-arm-musleabihf.node')
+            } else {
+              nativeBinding = require('@ruvector/graph-node-linux-arm-musleabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-arm-gnueabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-arm-gnueabihf.node')
+            } else {
+              nativeBinding = require('@ruvector/graph-node-linux-arm-gnueabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-riscv64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-riscv64-musl.node')
+            } else {
+              nativeBinding = require('@ruvector/graph-node-linux-riscv64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-riscv64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-riscv64-gnu.node')
+            } else {
+              nativeBinding = require('@ruvector/graph-node-linux-riscv64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 's390x':
+        localFileExisted = existsSync(
+          join(__dirname, 'index.linux-s390x-gnu.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.linux-s390x-gnu.node')
+          } else {
+            nativeBinding = require('@ruvector/graph-node-linux-s390x-gnu')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { QueryResultStream, HyperedgeStream, NodeStream, JsDistanceMetric, JsTemporalGranularity, GraphDatabase, version, hello } = nativeBinding
+
+module.exports.QueryResultStream = QueryResultStream
+module.exports.HyperedgeStream = HyperedgeStream
+module.exports.NodeStream = NodeStream
+module.exports.JsDistanceMetric = JsDistanceMetric
+module.exports.JsTemporalGranularity = JsTemporalGranularity
+module.exports.GraphDatabase = GraphDatabase
+module.exports.version = version
+module.exports.hello = hello

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@ruvector/graph-node",
+  "version": "0.1.15",
+  "description": "Native Node.js bindings for RuVector Graph Database with hypergraph support, Cypher queries, and persistence - 10x faster than WASM",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "author": "ruv.io Team <info@ruv.io> (https://ruv.io)",
+  "homepage": "https://ruv.io",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ruvnet/ruvector.git",
+    "directory": "npm/packages/graph-node"
+  },
+  "bugs": {
+    "url": "https://github.com/ruvnet/ruvector/issues"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "README.md"
+  ],
+  "scripts": {
+    "build:napi": "napi build --platform --release --cargo-cwd ../../../crates/ruvector-graph-node",
+    "test": "node test.js",
+    "benchmark": "node benchmark.js",
+    "publish:platforms": "node scripts/publish-platforms.js"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^2.18.0"
+  },
+  "optionalDependencies": {
+    "@ruvector/graph-node-linux-x64-gnu": "0.1.15",
+    "@ruvector/graph-node-linux-arm64-gnu": "0.1.15",
+    "@ruvector/graph-node-darwin-x64": "0.1.15",
+    "@ruvector/graph-node-darwin-arm64": "0.1.15",
+    "@ruvector/graph-node-win32-x64-msvc": "0.1.15"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "graph-database",
+    "graph",
+    "hypergraph",
+    "cypher",
+    "neo4j",
+    "vector-database",
+    "graph-query",
+    "knowledge-graph",
+    "property-graph",
+    "native",
+    "napi",
+    "rust",
+    "fast",
+    "performance",
+    "zero-copy",
+    "ai",
+    "machine-learning",
+    "rag",
+    "ruv",
+    "ruvector"
+  ]
+}