vectlite 0.1.8 → 0.1.12

package/README.md

@@ -31,8 +31,11 @@ db.upsert('doc2', embedding2, { source: 'notes', title: 'Billing' })
 // Search with filters
 const results = db.search(embeddingQuery, { k: 5, filter: { source: 'blog' } })
 
+// Query-free inspection
+console.log(db.count({ filter: { source: 'blog' } }))
+
 // Clean up
-db.compact()
+db.close()
 ```
 
 ## Features
@@ -43,6 +46,7 @@ db.compact()
 - **Dense vectors** -- cosine similarity with automatic HNSW indexing for large collections
 - **Sparse vectors** -- BM25-scored inverted index for keyword retrieval
 - **Hybrid search** -- dense + sparse fusion with linear or RRF strategies
+- **Vector quantization** -- scalar (int8, 4x), binary (32x), and product quantization (PQ) with 2-stage rescoring
 - **Rich metadata** -- string, number, boolean, null, array, and nested object values
 - **Crash-safe WAL** -- writes land in a write-ahead log first, then checkpoint with `compact()`
 - **Transactions** -- atomic batched writes with `db.transaction()`
@@ -62,9 +66,13 @@ db.compact()
 
 - **Physical collections** -- `vectlite.openStore()` manages a directory of independent databases
 - **Bulk ingestion** -- `bulkIngest()` with deferred index rebuilds for fast imports
+- **Listing & filtered counts** -- `list()` and `count({ namespace, filter })` without a vector query
+- **Delete by filter** -- `deleteByFilter()` for bulk deletion by metadata filter
 - **Snapshots** -- `db.snapshot(path)` creates a self-contained copy
 - **Backup / Restore** -- `db.backup(dir)` and `vectlite.restore(dir, path)` for full roundtrips
 - **Read-only mode** -- `vectlite.open(path, { readOnly: true })` for safe concurrent readers
+- **Explicit close** -- `db.close()` to release locks deterministically
+- **Lock timeouts** -- `lockTimeout` for bounded lock acquisition waits
 
 ## Usage
 
@@ -145,11 +153,23 @@ const restored = vectlite.restore('/backups/full/', 'restored.vdb')
 ### Read-Only Mode
 
 ```js
-const ro = vectlite.open('knowledge.vdb', { readOnly: true })
+const ro = vectlite.open('knowledge.vdb', { readOnly: true, lockTimeout: 5 })
 const results = ro.search(query, { k: 5 }) // Reads work
 ro.upsert(...)                              // Throws VectLiteError
 ```
 
+### Listing, Counting, and Lifecycle
+
+```js
+const db = vectlite.open('knowledge.vdb', { dimension: 384, lockTimeout: 5 })
+
+const records = db.list({ namespace: 'docs', filter: { stale: false }, limit: 20 })
+const count = db.count({ namespace: 'docs', filter: { source: 'blog' } })
+const deleted = db.deleteByFilter({ stale: true }, { namespace: 'docs' })
+
+db.close()
+```
+
 ### Search Diagnostics
 
 ```js
@@ -164,6 +184,82 @@ console.log(outcome.stats.used_ann)     // true
 console.log(outcome.results[0].explain) // Detailed scoring breakdown
 ```
 
+### Vector Quantization
+
+Reduce memory usage and accelerate search with quantized vectors. All methods use a 2-stage pipeline: fast quantized candidate selection followed by exact float32 rescoring.
+
+```js
+// Scalar quantization (int8) -- 4x memory reduction, minimal recall loss
+db.enableQuantization('scalar')
+
+// Binary quantization -- 32x memory reduction, best for normalized embeddings
+db.enableQuantization('binary', JSON.stringify({ rescoreMultiplier: 10 }))
+
+// Product quantization -- configurable compression for very large datasets
+db.enableQuantization('product', JSON.stringify({ numSubVectors: 16, numCentroids: 256 }))
+
+// Search works exactly the same -- quantization accelerates it transparently
+const results = db.search(queryEmbedding, { k: 10 })
+
+// Check quantization status
+console.log(db.isQuantized)         // true
+console.log(db.quantizationMethod)  // "scalar", "binary", or "product"
+
+// Disable quantization
+db.disableQuantization()
+```
+
+Quantization parameters persist across reopens in a `.vdb.quant` sidecar file. The quantized index auto-rebuilds on inserts and upserts.
+
+## Database Methods Reference
+
+### Write Methods
+
+| Method | Description |
+|---|---|
+| `db.upsert(id, vector, metadata, options)` | Insert or update a single record |
+| `db.insert(id, vector, metadata, options)` | Insert a record (throws on duplicate id) |
+| `db.upsertMany(records, { namespace })` | Upsert a batch of records |
+| `db.insertMany(records, { namespace })` | Insert a batch |
+| `db.bulkIngest(records, { namespace, batchSize })` | Fastest bulk import with batched WAL writes |
+| `db.delete(id, { namespace })` | Delete a single record |
+| `db.deleteMany(ids, { namespace })` | Delete multiple records by id |
+| `db.deleteByFilter(filter, { namespace })` | Delete all records matching a filter |
+
+### Read Methods
+
+| Method | Description |
+|---|---|
+| `db.get(id, { namespace })` | Get a single record by id |
+| `db.search(query, options)` | Search and return a list of results |
+| `db.searchWithStats(query, options)` | Search with detailed performance stats |
+| `db.count({ namespace, filter })` | Count records, optionally scoped by namespace/filter |
+| `db.list({ namespace, filter, limit, offset })` | List records without issuing a vector query |
+| `db.namespaces()` | List all namespaces |
+| `db.dimension` | Vector dimension (property) |
+| `db.path` | Database file path (property) |
+| `db.readOnly` | Whether the database is read-only (property) |
+
+### Quantization Methods
+
+| Method | Description |
+|---|---|
+| `db.enableQuantization(method, optionsJson)` | Enable quantization (`'scalar'`, `'binary'`, or `'product'`) |
+| `db.disableQuantization()` | Disable quantization and remove persisted parameters |
+| `db.isQuantized` | Whether quantization is enabled (property) |
+| `db.quantizationMethod` | Active method name or `null` (property) |
+
+### Maintenance Methods
+
+| Method | Description |
+|---|---|
+| `db.compact()` | Fold WAL into snapshot and persist ANN indexes |
+| `db.flush()` | Alias for `compact()` |
+| `db.snapshot(dest)` | Create a self-contained `.vdb` copy |
+| `db.backup(destDir)` | Full backup including ANN sidecar files |
+| `db.transaction()` | Begin an atomic transaction |
+| `db.close()` | Flush pending state, release the file lock, and invalidate the handle |
+
 ## Filter Operators
 
 | Operator | Example | Description |

package/index.d.ts

@@ -82,6 +82,16 @@ export interface WriteOptions {
   vectors?: NamedVectors | null
 }
 
+export interface CountOptions {
+  namespace?: string | null
+  filter?: Filter | null
+}
+
+export interface ListOptions extends CountOptions {
+  limit?: number | null
+  offset?: number | null
+}
+
 export interface BulkIngestOptions {
   namespace?: string | null
   batchSize?: number
@@ -108,6 +118,7 @@ export interface SearchOptions {
 export interface OpenOptions {
   dimension?: number | null
   readOnly?: boolean
+  lockTimeout?: number | null
 }
 
 export class VectLiteError extends Error {}
@@ -130,8 +141,10 @@ export class Database {
   readonly dimension: number
   readonly readOnly: boolean
 
-  count(): number
+  count(options?: CountOptions): number
   namespaces(): string[]
+  close(): void
+  list(options?: ListOptions): Record[]
   transaction(): Transaction
   insert(id: string, vector: number[], metadata?: Metadata | null, options?: WriteOptions): void
   upsert(id: string, vector: number[], metadata?: Metadata | null, options?: WriteOptions): void
@@ -141,6 +154,7 @@ export class Database {
   get(id: string, options?: { namespace?: string | null }): Record | null
   delete(id: string, options?: { namespace?: string | null }): boolean
   deleteMany(ids: string[], options?: { namespace?: string | null }): number
+  deleteByFilter(filter: Filter, options?: { namespace?: string | null }): number
   flush(): void
   compact(): void
   snapshot(dest: string): void

package/index.js

@@ -209,14 +209,31 @@ class Database {
     return wrapError(() => this._native.readOnly)
   }
 
-  count() {
-    return wrapError(() => this._native.count())
+  count(options = {}) {
+    return wrapError(() => this._native.count(options.namespace ?? null, encode(options.filter)))
   }
 
   namespaces() {
     return wrapError(() => this._native.namespaces())
   }
 
+  close() {
+    return wrapError(() => this._native.close())
+  }
+
+  list(options = {}) {
+    return wrapError(() =>
+      decode(
+        this._native.list(
+          options.namespace ?? null,
+          encode(options.filter),
+          options.limit ?? null,
+          options.offset ?? null,
+        ),
+      ),
+    )
+  }
+
   transaction() {
     return wrapError(() => new Transaction(this._native.transaction()))
   }
@@ -261,6 +278,10 @@ class Database {
     return wrapError(() => this._native.deleteMany(ids, options.namespace ?? null))
   }
 
+  deleteByFilter(filter, options = {}) {
+    return wrapError(() => this._native.deleteByFilter(encode(filter), options.namespace ?? null))
+  }
+
   flush() {
     return wrapError(() => this._native.flush())
   }
@@ -323,7 +344,9 @@ class Store {
 }
 
 function open(path, options = {}) {
-  return wrapError(() => new Database(native.open(path, options.dimension ?? null, options.readOnly ?? false)))
+  return wrapError(() =>
+    new Database(native.open(path, options.dimension ?? null, options.readOnly ?? false, options.lockTimeout ?? null)),
+  )
 }
 
 function openStore(root) {

package/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vectlite-node"
-version = "0.1.8"
+version = "0.1.12"
 edition = "2024"
 license = "MIT"
 description = "Node.js bindings for vectlite."

package/native/src/lib.rs

@@ -6,6 +6,10 @@ use napi::Error as NapiError;
 use napi::bindgen_prelude::*;
 use napi_derive::napi;
 use serde_json::{Map, Number, Value, json};
+use vectlite::quantization::{
+    BinaryQuantizationConfig, ProductQuantizationConfig, QuantizationConfig,
+    ScalarQuantizationConfig,
+};
 use vectlite::{
     Database as CoreDatabase, FusionStrategy, HybridSearchOptions, Metadata, MetadataFilter,
     MetadataValue, NamedVectors, Record, SearchOutcome, SearchResult, SparseVector,
@@ -133,9 +137,21 @@ impl NativeDatabase {
     }
 
     #[napi]
-    pub fn count(&self) -> Result<u32> {
+    pub fn count(&self, namespace: Option<String>, filter_json: Option<String>) -> Result<u32> {
+        let filter = filter_json
+            .as_ref()
+            .map(|json_str| {
+                let value: serde_json::Value = serde_json::from_str(json_str)
+                    .map_err(|e| err(format!("invalid filter JSON: {e}")))?;
+                json_to_filter(&value)
+            })
+            .transpose()?;
+        if namespace.is_none() && filter.is_none() {
+            let database = self.read()?;
+            return Ok(database.len() as u32);
+        }
         let database = self.read()?;
-        Ok(database.len() as u32)
+        Ok(database.count_filtered(namespace.as_deref(), filter.as_ref()) as u32)
     }
 
     #[napi]
@@ -145,11 +161,63 @@ impl NativeDatabase {
     }
 
     #[napi]
-    pub fn transaction(&self) -> NativeTransaction {
-        NativeTransaction {
+    pub fn close(&self) -> Result<()> {
+        let mut database = self.write()?;
+        database.close().map_err(to_napi_error)
+    }
+
+    #[napi]
+    pub fn list(
+        &self,
+        namespace: Option<String>,
+        filter_json: Option<String>,
+        limit: Option<u32>,
+        offset: Option<u32>,
+    ) -> Result<String> {
+        let filter = filter_json
+            .as_ref()
+            .map(|json_str| {
+                let value: serde_json::Value = serde_json::from_str(json_str)
+                    .map_err(|e| err(format!("invalid filter JSON: {e}")))?;
+                json_to_filter(&value)
+            })
+            .transpose()?;
+        let records = {
+            let database = self.read()?;
+            database
+                .list(
+                    namespace.as_deref(),
+                    filter.as_ref(),
+                    limit.unwrap_or(0) as usize,
+                    offset.unwrap_or(0) as usize,
+                )
+                .into_iter()
+                .cloned()
+                .collect::<Vec<_>>()
+        };
+        let json_records: Vec<Value> = records.iter().map(record_to_json).collect();
+        stringify_value(Value::Array(json_records))
+    }
+
+    #[napi(js_name = "deleteByFilter")]
+    pub fn delete_by_filter(&self, filter_json: String, namespace: Option<String>) -> Result<u32> {
+        let value: serde_json::Value = serde_json::from_str(&filter_json)
+            .map_err(|e| err(format!("invalid filter JSON: {e}")))?;
+        let filter = json_to_filter(&value)?;
+        let mut database = self.write_open()?;
+        database
+            .delete_by_filter(namespace.as_deref(), &filter)
+            .map(|count| count as u32)
+            .map_err(to_napi_error)
+    }
+
+    #[napi]
+    pub fn transaction(&self) -> Result<NativeTransaction> {
+        drop(self.read()?);
+        Ok(NativeTransaction {
             inner: Arc::clone(&self.inner),
             staged: Mutex::new(TransactionState::default()),
-        }
+        })
     }
 
     #[napi]
@@ -166,7 +234,7 @@ impl NativeDatabase {
         let sparse = parse_sparse_json(sparse_json)?;
         let vectors = parse_named_vectors_json(vectors_json)?;
         let vector = js_vector_to_core(vector, "vector")?;
-        let mut database = self.write()?;
+        let mut database = self.write_open()?;
         database
             .insert_with_vectors_in_namespace(
                 namespace.unwrap_or_default(),
@@ -193,7 +261,7 @@ impl NativeDatabase {
         let sparse = parse_sparse_json(sparse_json)?;
         let vectors = parse_named_vectors_json(vectors_json)?;
         let vector = js_vector_to_core(vector, "vector")?;
-        let mut database = self.write()?;
+        let mut database = self.write_open()?;
         database
             .upsert_with_vectors_in_namespace(
                 namespace.unwrap_or_default(),
@@ -209,7 +277,7 @@ impl NativeDatabase {
     #[napi(js_name = "insertMany")]
     pub fn insert_many(&self, records_json: String, namespace: Option<String>) -> Result<u32> {
         let records = parse_record_batch_json(&records_json, namespace.as_deref())?;
-        let mut database = self.write()?;
+        let mut database = self.write_open()?;
         database
             .insert_many(records)
             .map(|count| count as u32)
@@ -219,7 +287,7 @@ impl NativeDatabase {
     #[napi(js_name = "upsertMany")]
     pub fn upsert_many(&self, records_json: String, namespace: Option<String>) -> Result<u32> {
         let records = parse_record_batch_json(&records_json, namespace.as_deref())?;
-        let mut database = self.write()?;
+        let mut database = self.write_open()?;
         database
             .upsert_many(records)
             .map(|count| count as u32)
@@ -234,7 +302,7 @@ impl NativeDatabase {
         batch_size: u32,
     ) -> Result<u32> {
         let records = parse_record_batch_json(&records_json, namespace.as_deref())?;
-        let mut database = self.write()?;
+        let mut database = self.write_open()?;
         database
             .bulk_ingest(records, batch_size as usize)
             .map(|count| count as u32)
@@ -257,7 +325,7 @@ impl NativeDatabase {
 
     #[napi]
     pub fn delete(&self, id: String, namespace: Option<String>) -> Result<bool> {
-        let mut database = self.write()?;
+        let mut database = self.write_open()?;
         database
             .delete_in_namespace(&namespace.unwrap_or_default(), &id)
             .map_err(to_napi_error)
@@ -265,7 +333,7 @@ impl NativeDatabase {
 
     #[napi(js_name = "deleteMany")]
     pub fn delete_many(&self, ids: Vec<String>, namespace: Option<String>) -> Result<u32> {
-        let mut database = self.write()?;
+        let mut database = self.write_open()?;
         database
             .delete_many_in_namespace(&namespace.unwrap_or_default(), ids)
             .map(|count| count as u32)
@@ -274,16 +342,68 @@ impl NativeDatabase {
 
     #[napi]
     pub fn flush(&self) -> Result<()> {
-        let mut database = self.write()?;
+        let mut database = self.write_open()?;
         database.flush().map_err(to_napi_error)
     }
 
     #[napi]
     pub fn compact(&self) -> Result<()> {
-        let mut database = self.write()?;
+        let mut database = self.write_open()?;
         database.compact().map_err(to_napi_error)
     }
 
+    // -------------------------------------------------------------------
+    // Quantization
+    // -------------------------------------------------------------------
+
+    /// Enable quantization on the database.
+    /// `method`: "scalar", "binary", or "product"
+    /// `options_json`: JSON with optional keys: rescore_multiplier, num_sub_vectors, num_centroids, training_iterations
+    #[napi(js_name = "enableQuantization")]
+    pub fn enable_quantization(
+        &self,
+        method: Option<String>,
+        options_json: Option<String>,
+    ) -> Result<()> {
+        let method = method.as_deref().unwrap_or("scalar");
+        let (rescore_multiplier, num_sub_vectors, num_centroids, training_iterations) =
+            parse_quantization_options(options_json.as_deref())?;
+        let config = build_quantization_config(
+            method,
+            rescore_multiplier,
+            num_sub_vectors,
+            num_centroids,
+            training_iterations,
+        )?;
+        let mut database = self.write_open()?;
+        database.enable_quantization(config).map_err(to_napi_error)
+    }
+
+    /// Disable quantization and remove persisted parameters.
+    #[napi(js_name = "disableQuantization")]
+    pub fn disable_quantization(&self) -> Result<()> {
+        let mut database = self.write_open()?;
+        database.disable_quantization().map_err(to_napi_error)
+    }
+
+    /// Returns true if quantization is enabled.
+    #[napi(getter, js_name = "isQuantized")]
+    pub fn is_quantized(&self) -> Result<bool> {
+        let database = self.read()?;
+        Ok(database.is_quantized())
+    }
+
+    /// Returns the quantization method name if enabled, else null.
+    #[napi(getter, js_name = "quantizationMethod")]
+    pub fn quantization_method(&self) -> Result<Option<String>> {
+        let database = self.read()?;
+        Ok(database.quantization_config().map(|config| match config {
+            QuantizationConfig::Scalar(_) => "scalar".to_owned(),
+            QuantizationConfig::Binary(_) => "binary".to_owned(),
+            QuantizationConfig::Product(_) => "product".to_owned(),
+        }))
+    }
+
     #[napi]
     pub fn snapshot(&self, dest: String) -> Result<()> {
         let database = self.read()?;
@@ -478,9 +598,14 @@ impl NativeTransaction {
 
 impl NativeDatabase {
     fn read(&self) -> Result<RwLockReadGuard<'_, CoreDatabase>> {
-        self.inner
+        let database = self
+            .inner
             .read()
-            .map_err(|_| err("database read lock poisoned"))
+            .map_err(|_| err("database read lock poisoned"))?;
+        if database.is_closed() {
+            return Err(to_napi_error(closed_database_error()));
+        }
+        Ok(database)
     }
 
     fn write(&self) -> Result<RwLockWriteGuard<'_, CoreDatabase>> {
@@ -489,6 +614,14 @@ impl NativeDatabase {
             .map_err(|_| err("database write lock poisoned"))
     }
 
+    fn write_open(&self) -> Result<RwLockWriteGuard<'_, CoreDatabase>> {
+        let database = self.write()?;
+        if database.is_closed() {
+            return Err(to_napi_error(closed_database_error()));
+        }
+        Ok(database)
+    }
+
     fn execute_search(
         &self,
         query: Option<Vec<f32>>,
@@ -522,18 +655,40 @@ impl NativeDatabase {
 }
 
 #[napi]
-pub fn open(path: String, dimension: Option<u32>, read_only: bool) -> Result<NativeDatabase> {
+pub fn open(
+    path: String,
+    dimension: Option<u32>,
+    read_only: bool,
+    lock_timeout: Option<f64>,
+) -> Result<NativeDatabase> {
     let database = if read_only {
         if !Path::new(&path).exists() {
             return Err(err("cannot open non-existent database in read-only mode"));
         }
-        CoreDatabase::open_read_only(&path).map_err(to_napi_error)?
+        match lock_timeout {
+            Some(timeout) => CoreDatabase::open_read_only_with_timeout(&path, Some(timeout))
+                .map_err(to_napi_error)?,
+            None => CoreDatabase::open_read_only(&path).map_err(to_napi_error)?,
+        }
     } else if Path::new(&path).exists() {
-        match dimension {
-            Some(dimension) => {
+        match (dimension, lock_timeout) {
+            (Some(dimension), Some(timeout)) => {
+                let db = CoreDatabase::open_with_timeout(&path, timeout).map_err(to_napi_error)?;
+                if db.dimension() != dimension as usize {
+                    return Err(to_napi_error(vectlite::VectLiteError::DimensionMismatch {
+                        expected: db.dimension(),
+                        found: dimension as usize,
+                    }));
+                }
+                db
+            }
+            (Some(dimension), None) => {
                 CoreDatabase::open_or_create(&path, dimension as usize).map_err(to_napi_error)?
             }
-            None => CoreDatabase::open(&path).map_err(to_napi_error)?,
+            (None, Some(timeout)) => {
+                CoreDatabase::open_with_timeout(&path, timeout).map_err(to_napi_error)?
+            }
+            (None, None) => CoreDatabase::open(&path).map_err(to_napi_error)?,
         }
     } else {
         let Some(dimension) = dimension else {
@@ -1212,3 +1367,74 @@ fn err(message: impl Into<String>) -> NapiError {
 fn to_napi_error(error: vectlite::VectLiteError) -> NapiError {
     err(error.to_string())
 }
+
+fn closed_database_error() -> vectlite::VectLiteError {
+    vectlite::VectLiteError::InvalidFormat("database is closed".to_owned())
+}
+
+fn parse_quantization_options(
+    options_json: Option<&str>,
+) -> Result<(Option<usize>, Option<usize>, Option<usize>, Option<usize>)> {
+    let Some(json_str) = options_json else {
+        return Ok((None, None, None, None));
+    };
+    let value: Value = serde_json::from_str(json_str)
+        .map_err(|e| err(format!("invalid quantization options JSON: {e}")))?;
+    let obj = value
+        .as_object()
+        .ok_or_else(|| err("quantization options must be a JSON object"))?;
+
+    let rescore_multiplier = obj
+        .get("rescoreMultiplier")
+        .or_else(|| obj.get("rescore_multiplier"))
+        .and_then(|v| v.as_u64())
+        .map(|v| v as usize);
+    let num_sub_vectors = obj
+        .get("numSubVectors")
+        .or_else(|| obj.get("num_sub_vectors"))
+        .and_then(|v| v.as_u64())
+        .map(|v| v as usize);
+    let num_centroids = obj
+        .get("numCentroids")
+        .or_else(|| obj.get("num_centroids"))
+        .and_then(|v| v.as_u64())
+        .map(|v| v as usize);
+    let training_iterations = obj
+        .get("trainingIterations")
+        .or_else(|| obj.get("training_iterations"))
+        .and_then(|v| v.as_u64())
+        .map(|v| v as usize);
+
+    Ok((
+        rescore_multiplier,
+        num_sub_vectors,
+        num_centroids,
+        training_iterations,
+    ))
+}
+
+fn build_quantization_config(
+    method: &str,
+    rescore_multiplier: Option<usize>,
+    num_sub_vectors: Option<usize>,
+    num_centroids: Option<usize>,
+    training_iterations: Option<usize>,
+) -> Result<QuantizationConfig> {
+    match method {
+        "scalar" | "int8" => Ok(QuantizationConfig::Scalar(ScalarQuantizationConfig {
+            rescore_multiplier: rescore_multiplier.unwrap_or(5),
+        })),
+        "binary" => Ok(QuantizationConfig::Binary(BinaryQuantizationConfig {
+            rescore_multiplier: rescore_multiplier.unwrap_or(10),
+        })),
+        "product" | "pq" => Ok(QuantizationConfig::Product(ProductQuantizationConfig {
+            num_sub_vectors: num_sub_vectors.unwrap_or(16),
+            num_centroids: num_centroids.unwrap_or(256),
+            training_iterations: training_iterations.unwrap_or(20),
+            rescore_multiplier: rescore_multiplier.unwrap_or(10),
+        })),
+        other => Err(err(format!(
+            "unknown quantization method '{other}'. Expected: 'scalar', 'binary', or 'product'"
+        ))),
+    }
+}

package/native/vectlite-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vectlite-core"
-version = "0.1.8"
+version = "0.1.12"
 edition = "2024"
 license = "MIT"
 description = "Core storage engine for vectlite."