@ruvector/rvf 0.1.2 → 0.1.4

package/dist/types.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Distance metric for vector similarity search.
+ *
+ * - `l2`         Squared Euclidean distance.
+ * - `cosine`     Cosine distance (1 - cosine_similarity).
+ * - `dotproduct`  Negated inner (dot) product.
+ */
+export type DistanceMetric = 'l2' | 'cosine' | 'dotproduct';
+/**
+ * Compression profile for stored vectors.
+ *
+ * - `none`    Raw fp32 vectors.
+ * - `scalar`  Scalar quantization (int8).
+ * - `product` Product quantization.
+ */
+export type CompressionProfile = 'none' | 'scalar' | 'product';
+/**
+ * Hardware profile selector.
+ *
+ * 0 = Generic, 1 = Core, 2 = Hot, 3 = Full.
+ */
+export type HardwareProfile = 0 | 1 | 2 | 3;
+/** Options for creating a new RVF store. */
+export interface RvfOptions {
+    /** Vector dimensionality (required, must be > 0). */
+    dimensions: number;
+    /** Distance metric for similarity search. Default: `'l2'`. */
+    metric?: DistanceMetric;
+    /** Hardware profile identifier. Default: `0` (Generic). */
+    profile?: HardwareProfile;
+    /** Compression profile. Default: `'none'`. */
+    compression?: CompressionProfile;
+    /** Enable segment signing. Default: `false`. */
+    signing?: boolean;
+    /** HNSW M parameter: max edges per node per layer. Default: `16`. */
+    m?: number;
+    /** HNSW ef_construction: beam width during index build. Default: `200`. */
+    efConstruction?: number;
+}
+/** Primitive value types usable in filter expressions. */
+export type RvfFilterValue = number | string | boolean;
+/**
+ * A filter expression for metadata-based vector filtering.
+ *
+ * Leaf operators compare a `fieldId` against a literal `value`.
+ * Composite operators combine sub-expressions with boolean logic.
+ */
+export type RvfFilterExpr = {
+    op: 'eq';
+    fieldId: number;
+    value: RvfFilterValue;
+} | {
+    op: 'ne';
+    fieldId: number;
+    value: RvfFilterValue;
+} | {
+    op: 'lt';
+    fieldId: number;
+    value: RvfFilterValue;
+} | {
+    op: 'le';
+    fieldId: number;
+    value: RvfFilterValue;
+} | {
+    op: 'gt';
+    fieldId: number;
+    value: RvfFilterValue;
+} | {
+    op: 'ge';
+    fieldId: number;
+    value: RvfFilterValue;
+} | {
+    op: 'in';
+    fieldId: number;
+    values: RvfFilterValue[];
+} | {
+    op: 'range';
+    fieldId: number;
+    low: RvfFilterValue;
+    high: RvfFilterValue;
+} | {
+    op: 'and';
+    exprs: RvfFilterExpr[];
+} | {
+    op: 'or';
+    exprs: RvfFilterExpr[];
+} | {
+    op: 'not';
+    expr: RvfFilterExpr;
+};
+/** Options controlling a query operation. */
+export interface RvfQueryOptions {
+    /** HNSW ef_search parameter (beam width during search). Default: `100`. */
+    efSearch?: number;
+    /** Optional metadata filter expression. */
+    filter?: RvfFilterExpr;
+    /** Query timeout in milliseconds (0 = no timeout). Default: `0`. */
+    timeoutMs?: number;
+}
+/** A single search result: vector ID and distance. */
+export interface RvfSearchResult {
+    /** The vector's unique identifier (string-encoded u64). */
+    id: string;
+    /** Distance from the query vector (lower = more similar). */
+    distance: number;
+}
+/** Result of a batch ingest operation. */
+export interface RvfIngestResult {
+    /** Number of vectors successfully ingested. */
+    accepted: number;
+    /** Number of vectors rejected. */
+    rejected: number;
+    /** Manifest epoch after the ingest commit. */
+    epoch: number;
+}
+/** Result of a delete operation. */
+export interface RvfDeleteResult {
+    /** Number of vectors soft-deleted. */
+    deleted: number;
+    /** Manifest epoch after the delete commit. */
+    epoch: number;
+}
+/** Result of a compaction operation. */
+export interface RvfCompactionResult {
+    /** Number of segments compacted. */
+    segmentsCompacted: number;
+    /** Bytes of dead space reclaimed. */
+    bytesReclaimed: number;
+    /** Manifest epoch after compaction commit. */
+    epoch: number;
+}
+/** Compaction state as reported in store status. */
+export type CompactionState = 'idle' | 'running' | 'emergency';
+/** A snapshot of the store's current state. */
+export interface RvfStatus {
+    /** Total number of live (non-deleted) vectors. */
+    totalVectors: number;
+    /** Total number of segments in the file. */
+    totalSegments: number;
+    /** Total file size in bytes. */
+    fileSizeBytes: number;
+    /** Current manifest epoch. */
+    epoch: number;
+    /** Hardware profile identifier. */
+    profileId: number;
+    /** Current compaction state. */
+    compactionState: CompactionState;
+    /** Ratio of dead space to total (0.0 - 1.0). */
+    deadSpaceRatio: number;
+    /** Whether the store is open in read-only mode. */
+    readOnly: boolean;
+}
+/** A single entry for batch ingestion. */
+export interface RvfIngestEntry {
+    /** Unique vector identifier. */
+    id: string;
+    /** The embedding vector (must match store dimensions). */
+    vector: Float32Array | number[];
+    /** Optional per-vector metadata fields. */
+    metadata?: Record<string, RvfFilterValue>;
+}
+/** Derivation type for creating derived stores. */
+export type DerivationType = 'filter' | 'merge' | 'snapshot' | 'transform';
+/** Data returned from kernel extraction. */
+export interface RvfKernelData {
+    /** Serialized KernelHeader bytes. */
+    header: Uint8Array;
+    /** Raw kernel image bytes. */
+    image: Uint8Array;
+}
+/** Data returned from eBPF extraction. */
+export interface RvfEbpfData {
+    /** Serialized EbpfHeader bytes. */
+    header: Uint8Array;
+    /** Program bytecode + optional BTF. */
+    payload: Uint8Array;
+}
+/** Information about a segment in the store. */
+export interface RvfSegmentInfo {
+    /** Segment ID. */
+    id: number;
+    /** File offset of the segment. */
+    offset: number;
+    /** Payload length in bytes. */
+    payloadLength: number;
+    /** Segment type name (e.g. "vec", "manifest", "kernel"). */
+    segType: string;
+}
+/** Identifies which backend implementation to use. */
+export type BackendType = 'node' | 'wasm' | 'auto';

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruvector/rvf",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "RuVector Format — unified TypeScript SDK for vector intelligence",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -12,24 +12,14 @@
       "require": "./dist/index.js"
     }
   },
-  "files": [
-    "dist/",
-    "package.json"
-  ],
+  "files": ["dist/", "package.json"],
   "scripts": {
     "build": "tsc",
     "test": "jest",
     "bench": "tsx bench/index.ts",
     "typecheck": "tsc --noEmit"
   },
-  "keywords": [
-    "vector",
-    "database",
-    "binary-format",
-    "hnsw",
-    "simd",
-    "rvf"
-  ],
+  "keywords": ["vector", "database", "binary-format", "hnsw", "simd", "rvf"],
   "license": "MIT",
   "repository": "https://github.com/ruvnet/ruvector",
   "dependencies": {