native-vector-store 0.3.6 → 0.3.8

package/README.md

@@ -390,9 +390,10 @@ Performance on typical hardware (M1 MacBook Pro):
 
 | Operation | Documents | Time | Throughput |
 |-----------|-----------|------|------------|
+| Loading (from disk) | 10,000 | 153ms | 65k docs/sec |
 | Loading (from disk) | 100,000 | ~560ms | 178k docs/sec |
 | Loading (production) | 65,000 | 15-20s | 3.2-4.3k docs/sec |
-| Search (k=10) | 10,000 corpus | 1-2ms | 500-1000 queries/sec |
+| Search (k=10) | 10,000 corpus | 2ms | 500 queries/sec |
 | Search (k=10) | 65,000 corpus | 40-45ms | 20-25 queries/sec |
 | Search (k=100) | 100,000 corpus | 8-12ms | 80-125 queries/sec |
 | Normalization | 100,000 | <100ms | 1M+ docs/sec |
@@ -503,8 +504,8 @@ Performance on M1 MacBook Pro with 1536-dimensional embeddings:
 
 | Operation | Document Count | Time | Rate |
 |-----------|---------------|------|------|
-| Load | 10,000 | 245ms | 40.8k docs/sec |
-| Search | 10,000 | 3.2ms | 3.1M docs/sec |
+| Load | 10,000 | 153ms | 65.4k docs/sec |
+| Search | 10,000 | 2ms | 5M docs/sec |
 | Normalize | 10,000 | 12ms | 833k docs/sec |
 
 *Results may vary based on hardware and document characteristics.*

package/docs/index.html

@@ -383,6 +383,12 @@ const response = await server.handleMCPRequest('vector_search', {
 <tbody>
 <tr>
 <td>Loading (from disk)</td>
+<td>10,000</td>
+<td>153ms</td>
+<td>65k docs/sec</td>
+</tr>
+<tr>
+<td>Loading (from disk)</td>
 <td>100,000</td>
 <td>~560ms</td>
 <td>178k docs/sec</td>
@@ -396,8 +402,8 @@ const response = await server.handleMCPRequest('vector_search', {
 <tr>
 <td>Search (k=10)</td>
 <td>10,000 corpus</td>
-<td>1-2ms</td>
-<td>500-1000 queries/sec</td>
+<td>2ms</td>
+<td>500 queries/sec</td>
 </tr>
 <tr>
 <td>Search (k=10)</td>
@@ -591,14 +597,14 @@ npm run example
 <tr>
 <td>Load</td>
 <td>10,000</td>
-<td>245ms</td>
-<td>40.8k docs/sec</td>
+<td>153ms</td>
+<td>65.4k docs/sec</td>
 </tr>
 <tr>
 <td>Search</td>
 <td>10,000</td>
-<td>3.2ms</td>
-<td>3.1M docs/sec</td>
+<td>2ms</td>
+<td>5M docs/sec</td>
 </tr>
 <tr>
 <td>Normalize</td>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "native-vector-store",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "High-performance local vector store with SIMD optimization for MCP servers",
   "main": "index.js",
   "types": "lib/index.d.ts",

package/src/binding.cc

@@ -79,9 +79,9 @@ public:
         }
         
         auto add_error = store_->add_document(json_doc);
-        if (add_error) {
+        if (add_error != VectorStoreError::SUCCESS) {
             Napi::Error::New(info.Env(), 
-                std::string("Document add error: ") + simdjson::error_message(add_error))
+                std::string("Document add error: ") + vector_store_error_message(add_error))
                 .ThrowAsJavaScriptException();
             return;
         }

package/src/test_main.cpp

@@ -33,8 +33,8 @@ void test_single_document() {
         
         std::cout << "Adding document..." << std::endl;
         auto add_error = store.add_document(doc);
-        if (add_error) {
-            std::cerr << "Document add error: " << simdjson::error_message(add_error) << std::endl;
+        if (add_error != VectorStoreError::SUCCESS) {
+            std::cerr << "Document add error: " << vector_store_error_message(add_error) << std::endl;
             return;
         }
         std::cout << "Document added successfully. Store size: " << store.size() << std::endl;
@@ -115,8 +115,8 @@ void test_load_directory(const std::string& path) {
                         }
                         
                         auto add_error = store.add_document(doc_obj);
-                        if (add_error) {
-                            std::cerr << "  Error adding document: " << simdjson::error_message(add_error) << std::endl;
+                        if (add_error != VectorStoreError::SUCCESS) {
+                            std::cerr << "  Error adding document: " << vector_store_error_message(add_error) << std::endl;
                             error_count++;
                         } else {
                             doc_count++;
@@ -132,8 +132,8 @@ void test_load_directory(const std::string& path) {
                     std::cout << "  Detected single document" << std::endl;
                     std::cout << "  Adding to store..." << std::endl;
                     auto add_error = store.add_document(json_doc);
-                    if (add_error) {
-                        std::cerr << "  Error adding document: " << simdjson::error_message(add_error) << std::endl;
+                    if (add_error != VectorStoreError::SUCCESS) {
+                        std::cerr << "  Error adding document: " << vector_store_error_message(add_error) << std::endl;
                     } else {
                         std::cout << "  Document added successfully";
                     }

package/src/test_stress.cpp

@@ -107,7 +107,7 @@ void test_phase_enforcement() {
         simdjson::ondemand::document doc;
         if (!parser.iterate(padded).get(doc)) {
             auto error = store.add_document(doc);
-            assert(error == simdjson::SUCCESS);
+            assert(error == VectorStoreError::SUCCESS);
         }
     }
     
@@ -127,7 +127,7 @@ void test_phase_enforcement() {
     simdjson::ondemand::document doc;
     parser.iterate(padded).get(doc);
     auto error = store.add_document(doc);
-    assert(error == simdjson::INCORRECT_TYPE);
+    assert(error == VectorStoreError::STORE_ALREADY_FINALIZED);
     std::cout << "   ✅ Document addition correctly blocked after finalization\n";
 }
 
@@ -159,11 +159,11 @@ void test_oversize_allocation() {
     auto error = parser.iterate(padded).get(doc);
     if (!error) {
         // This should fail in the allocator
-        error = store.add_document(doc);
-        if (error == simdjson::MEMALLOC) {
+        auto error = store.add_document(doc);
+        if (error == VectorStoreError::MEMORY_ALLOCATION_FAILED) {
             std::cout << "✅ Correctly rejected oversize allocation\n";
         } else {
-            std::cout << "❌ Should have failed with MEMALLOC error, got: " << simdjson::error_message(error) << "\n";
+            std::cout << "❌ Should have failed with MEMALLOC error, got: " << vector_store_error_message(error) << "\n";
             std::exit(1);
         }
     } else {
@@ -231,7 +231,7 @@ void test_phase_separation() {
         simdjson::ondemand::document doc;
         if (!parser.iterate(padded).get(doc)) {
             auto error = store.add_document(doc);
-            if (!error) {
+            if (error == VectorStoreError::SUCCESS) {
                 docs_loaded++;
             }
         }
@@ -260,7 +260,7 @@ void test_phase_separation() {
         simdjson::ondemand::document doc;
         parser.iterate(padded).get(doc);
         auto error = store.add_document(doc);
-        assert(error == simdjson::INCORRECT_TYPE);
+        assert(error == VectorStoreError::STORE_ALREADY_FINALIZED);
         std::cout << "   ✅ Document additions correctly blocked after finalization\n";
     }
     

package/src/vector_store.cpp

@@ -71,6 +71,7 @@ ArenaAllocator::~ArenaAllocator() {
     }
 }
 
+
 // TopK implementation
 
 TopK::TopK(size_t k) : k(k) { 
@@ -110,21 +111,33 @@ void TopK::merge(const TopK& other) {
 
 VectorStore::VectorStore(size_t dim) : dim_(dim) {
     entries_.resize(1'000'000);  // Pre-size with default-constructed entries
+    
+    // Prepare per-thread arena allocators for zero-contention parallel loading
+    int max_threads = omp_get_max_threads();
+    thread_arenas_.reserve(max_threads);
+    for (int i = 0; i < max_threads; ++i) {
+        thread_arenas_.emplace_back(std::make_unique<ArenaAllocator>());
+    }
 }
 
-simdjson::error_code VectorStore::add_document(simdjson::ondemand::document& json_doc) {
+VectorStore::BatchState& VectorStore::get_batch_state() {
+    thread_local BatchState state;
+    return state;
+}
+
+VectorStoreError VectorStore::add_document(simdjson::ondemand::document& json_doc) {
     simdjson::ondemand::object obj;
     auto error = json_doc.get_object().get(obj);
     if (error) {
-        return error;
+        return map_simdjson_error(error);
     }
     return add_document(obj);
 }
 
-simdjson::error_code VectorStore::add_document(simdjson::ondemand::object& json_doc) {
+VectorStoreError VectorStore::add_document(simdjson::ondemand::object& json_doc) {
     // Cannot add documents after finalization
     if (is_finalized_.load(std::memory_order_acquire)) {
-        return simdjson::INCORRECT_TYPE;
+        return VectorStoreError::STORE_ALREADY_FINALIZED;
     }
     
     // Parse with error handling
@@ -134,7 +147,7 @@ simdjson::error_code VectorStore::add_document(simdjson::ondemand::object& json_
         if (error == simdjson::NO_SUCH_FIELD) {
             fprintf(stderr, "Missing required field 'id'\n");
         }
-        return error;
+        return map_simdjson_error(error);
     }
     
     // Auto-detect text field type on first document, then use that for all subsequent documents
@@ -158,10 +171,10 @@ simdjson::error_code VectorStore::add_document(simdjson::ondemand::object& json_
                 if (error == simdjson::NO_SUCH_FIELD) {
                     fprintf(stderr, "Missing required field 'text' or 'content'\n");
                 }
-                return error;
+                return map_simdjson_error(error);
             }
         } else {
-            return error;
+            return map_simdjson_error(error);
         }
     } else if (field_type == TextFieldType::TEXT) {
         // Use 'text' field directly
@@ -170,7 +183,7 @@ simdjson::error_code VectorStore::add_document(simdjson::ondemand::object& json_
             if (error == simdjson::NO_SUCH_FIELD) {
                 fprintf(stderr, "Missing required field 'text' (detected from first document)\n");
             }
-            return error;
+            return map_simdjson_error(error);
         }
     } else { // TextFieldType::CONTENT
         // Use 'content' field directly
@@ -179,27 +192,18 @@ simdjson::error_code VectorStore::add_document(simdjson::ondemand::object& json_
             if (error == simdjson::NO_SUCH_FIELD) {
                 fprintf(stderr, "Missing required field 'content' (detected from first document)\n");
             }
-            return error;
+            return map_simdjson_error(error);
         }
     }
     
-    // Calculate sizes
-    size_t emb_size = dim_ * sizeof(float);
-    size_t id_size = id.size() + 1;
-    size_t text_size = text.size() + 1;
-    
-    // Allocate temporary buffer for embedding
-    std::vector<float> temp_embedding;
-    temp_embedding.reserve(dim_);
-    
-    // Process metadata and embedding first
+    // Process metadata and embedding first to get raw JSON before allocation
     simdjson::ondemand::object metadata;
     error = json_doc["metadata"].get_object().get(metadata);
     if (error) {
         if (error == simdjson::NO_SUCH_FIELD) {
             fprintf(stderr, "Missing required field 'metadata'\n");
         }
-        return error;
+        return map_simdjson_error(error);
     }
     
     simdjson::ondemand::array emb_array;
@@ -208,21 +212,27 @@ simdjson::error_code VectorStore::add_document(simdjson::ondemand::object& json_
         if (error == simdjson::NO_SUCH_FIELD) {
             fprintf(stderr, "Missing required field 'embedding' inside 'metadata'\n");
         }
-        return error;
+        return map_simdjson_error(error);
     }
     
-    // Consume the array before touching anything else  
+    // Use thread-local temporary buffer for embedding to avoid allocation/free per document
+    thread_local std::vector<float> temp_embedding;
+    temp_embedding.clear();
+    temp_embedding.reserve(dim_);
+    
+    // Fill embedding into temporary buffer
     size_t i = 0;
     for (auto value_result : emb_array) {
         simdjson::ondemand::value v;
         error = value_result.get(v);
-        if (error) return error;
+        if (error) return map_simdjson_error(error);
         double val;
         error = v.get_double().get(val);
-        if (error) return error;
+        if (error) return map_simdjson_error(error);
         
         if (i >= dim_) {
-            return simdjson::CAPACITY; // Too many embedding values
+            fprintf(stderr, "Too many embedding values: expected %zu, got at least %zu\n", dim_, i+1);
+            return VectorStoreError::DIMENSION_MISMATCH;
         }
         temp_embedding.push_back(float(val));
         i++;
@@ -230,19 +240,39 @@ simdjson::error_code VectorStore::add_document(simdjson::ondemand::object& json_
     
     // Verify we got the expected number of embedding values
     if (i != dim_) {
-        return simdjson::INCORRECT_TYPE; // Wrong embedding dimension
+        fprintf(stderr, "Wrong embedding dimension: expected %zu, got %zu\n", dim_, i);
+        return VectorStoreError::DIMENSION_MISMATCH;
     }
     
     // Now it is safe to take the raw metadata JSON
     std::string_view raw_json;
     error = metadata.raw_json().get(raw_json);
-    if (error) return error;
+    if (error) return map_simdjson_error(error);
+    
+    // Calculate sizes
+    size_t emb_size = dim_ * sizeof(float);
+    size_t id_size = id.size() + 1;
+    size_t text_size = text.size() + 1;
     size_t meta_size = raw_json.size() + 1;
     
-    // Single arena allocation
-    char* base = (char*)arena_.allocate(emb_size + id_size + text_size + meta_size);
+    // Use per-thread arena allocator for zero-contention allocation
+    // Get thread ID and dispatch to appropriate arena
+#ifdef _OPENMP
+    int tid = omp_get_thread_num();
+#else
+    // For non-OpenMP builds, assign each std::thread a small integer ID
+    static std::atomic<size_t> counter{0};
+    static thread_local size_t tid = counter++;
+#endif
+    
+    // Ensure thread ID is within bounds
+    if (tid >= static_cast<int>(thread_arenas_.size())) {
+        tid = 0; // Fallback to first arena
+    }
+    
+    char* base = (char*)thread_arenas_[tid]->allocate(emb_size + id_size + text_size + meta_size);
     if (!base) {
-        return simdjson::MEMALLOC;  // Allocation failed
+        return VectorStoreError::MEMORY_ALLOCATION_FAILED;
     }
     
     // Layout: [embedding][id][text][metadata_json]
@@ -251,7 +281,7 @@ simdjson::error_code VectorStore::add_document(simdjson::ondemand::object& json_
     char* text_ptr = id_ptr + id_size;
     char* meta_ptr = text_ptr + text_size;
     
-    // Copy embedding from temporary buffer
+    // Copy embedding from thread-local buffer (no heap allocation per call)
     std::memcpy(emb_ptr, temp_embedding.data(), emb_size);
     
     // Copy strings (adding null terminator)
@@ -270,7 +300,7 @@ simdjson::error_code VectorStore::add_document(simdjson::ondemand::object& json_
     // Bounds check
     if (idx >= entries_.size()) {
         count_.fetch_sub(1, std::memory_order_relaxed);
-        return simdjson::CAPACITY;
+        return VectorStoreError::CAPACITY_EXCEEDED;
     }
     
     // Construct entry directly - no synchronization needed
@@ -286,7 +316,7 @@ simdjson::error_code VectorStore::add_document(simdjson::ondemand::object& json_
     
     entries_[idx] = entry;
     
-    return simdjson::SUCCESS;
+    return VectorStoreError::SUCCESS;
 }
 
 void VectorStore::finalize() {
@@ -399,4 +429,4 @@ size_t VectorStore::size() const {
 
 bool VectorStore::is_finalized() const {
     return is_finalized_.load(std::memory_order_acquire);
-}
+}

package/src/vector_store.h

@@ -13,6 +13,138 @@
 #include <algorithm>
 #include <functional>
 
+// Custom error codes for VectorStore
+enum class VectorStoreError {
+    SUCCESS = 0,
+    MEMORY_ALLOCATION_FAILED,
+    DIMENSION_MISMATCH,
+    MISSING_FIELD,
+    WRONG_TYPE,
+    STORE_NOT_FINALIZED,
+    STORE_ALREADY_FINALIZED,
+    CAPACITY_EXCEEDED,
+    JSON_PARSE_ERROR,
+    FILE_IO_ERROR,
+    UNKNOWN_ERROR,
+    // JSON parsing specific errors (mapped from simdjson)
+    JSON_CAPACITY,
+    JSON_TAPE_ERROR,
+    JSON_DEPTH_ERROR,
+    JSON_STRING_ERROR,
+    JSON_T_ATOM_ERROR,
+    JSON_F_ATOM_ERROR,
+    JSON_N_ATOM_ERROR,
+    JSON_NUMBER_ERROR,
+    JSON_UTF8_ERROR,
+    JSON_UNINITIALIZED,
+    JSON_EMPTY,
+    JSON_UNESCAPED_CHARS,
+    JSON_UNCLOSED_STRING,
+    JSON_UNSUPPORTED_ARCHITECTURE,
+    JSON_INCORRECT_TYPE,
+    JSON_NUMBER_OUT_OF_RANGE,
+    JSON_INDEX_OUT_OF_BOUNDS,
+    JSON_NO_SUCH_FIELD,
+    JSON_IO_ERROR,
+    JSON_INVALID_JSON_POINTER,
+    JSON_INVALID_URI_FRAGMENT,
+    JSON_UNEXPECTED_ERROR,
+    JSON_PARSER_IN_USE,
+    JSON_OUT_OF_ORDER_ITERATION,
+    JSON_INSUFFICIENT_PADDING,
+    JSON_INCOMPLETE_ARRAY_OR_OBJECT,
+    JSON_SCALAR_DOCUMENT_AS_VALUE,
+    JSON_OUT_OF_BOUNDS,
+    JSON_TRAILING_CONTENT
+};
+
+// Map simdjson error to VectorStoreError
+inline VectorStoreError map_simdjson_error(simdjson::error_code error) {
+    using namespace simdjson;
+    switch (error) {
+        case SUCCESS: return VectorStoreError::SUCCESS;
+        case CAPACITY: return VectorStoreError::JSON_CAPACITY;
+        case MEMALLOC: return VectorStoreError::MEMORY_ALLOCATION_FAILED;
+        case TAPE_ERROR: return VectorStoreError::JSON_TAPE_ERROR;
+        case DEPTH_ERROR: return VectorStoreError::JSON_DEPTH_ERROR;
+        case STRING_ERROR: return VectorStoreError::JSON_STRING_ERROR;
+        case T_ATOM_ERROR: return VectorStoreError::JSON_T_ATOM_ERROR;
+        case F_ATOM_ERROR: return VectorStoreError::JSON_F_ATOM_ERROR;
+        case N_ATOM_ERROR: return VectorStoreError::JSON_N_ATOM_ERROR;
+        case NUMBER_ERROR: return VectorStoreError::JSON_NUMBER_ERROR;
+        case UTF8_ERROR: return VectorStoreError::JSON_UTF8_ERROR;
+        case UNINITIALIZED: return VectorStoreError::JSON_UNINITIALIZED;
+        case EMPTY: return VectorStoreError::JSON_EMPTY;
+        case UNESCAPED_CHARS: return VectorStoreError::JSON_UNESCAPED_CHARS;
+        case UNCLOSED_STRING: return VectorStoreError::JSON_UNCLOSED_STRING;
+        case UNSUPPORTED_ARCHITECTURE: return VectorStoreError::JSON_UNSUPPORTED_ARCHITECTURE;
+        case INCORRECT_TYPE: return VectorStoreError::JSON_INCORRECT_TYPE;
+        case NUMBER_OUT_OF_RANGE: return VectorStoreError::JSON_NUMBER_OUT_OF_RANGE;
+        case INDEX_OUT_OF_BOUNDS: return VectorStoreError::JSON_INDEX_OUT_OF_BOUNDS;
+        case NO_SUCH_FIELD: return VectorStoreError::JSON_NO_SUCH_FIELD;
+        case IO_ERROR: return VectorStoreError::JSON_IO_ERROR;
+        case INVALID_JSON_POINTER: return VectorStoreError::JSON_INVALID_JSON_POINTER;
+        case INVALID_URI_FRAGMENT: return VectorStoreError::JSON_INVALID_URI_FRAGMENT;
+        case UNEXPECTED_ERROR: return VectorStoreError::JSON_UNEXPECTED_ERROR;
+        case PARSER_IN_USE: return VectorStoreError::JSON_PARSER_IN_USE;
+        case OUT_OF_ORDER_ITERATION: return VectorStoreError::JSON_OUT_OF_ORDER_ITERATION;
+        case INSUFFICIENT_PADDING: return VectorStoreError::JSON_INSUFFICIENT_PADDING;
+        case INCOMPLETE_ARRAY_OR_OBJECT: return VectorStoreError::JSON_INCOMPLETE_ARRAY_OR_OBJECT;
+        case SCALAR_DOCUMENT_AS_VALUE: return VectorStoreError::JSON_SCALAR_DOCUMENT_AS_VALUE;
+        case OUT_OF_BOUNDS: return VectorStoreError::JSON_OUT_OF_BOUNDS;
+        case TRAILING_CONTENT: return VectorStoreError::JSON_TRAILING_CONTENT;
+        default: return VectorStoreError::JSON_PARSE_ERROR;
+    }
+}
+
+// Convert VectorStoreError to string for error messages
+inline const char* vector_store_error_message(VectorStoreError error) {
+    switch (error) {
+        case VectorStoreError::SUCCESS: return "Success";
+        case VectorStoreError::MEMORY_ALLOCATION_FAILED: return "Memory allocation failed";
+        case VectorStoreError::DIMENSION_MISMATCH: return "Embedding dimension mismatch";
+        case VectorStoreError::MISSING_FIELD: return "Required field missing";
+        case VectorStoreError::WRONG_TYPE: return "Wrong field type";
+        case VectorStoreError::STORE_NOT_FINALIZED: return "Store must be finalized before searching";
+        case VectorStoreError::STORE_ALREADY_FINALIZED: return "Store already finalized, cannot add more documents";
+        case VectorStoreError::CAPACITY_EXCEEDED: return "Store capacity exceeded";
+        case VectorStoreError::JSON_PARSE_ERROR: return "JSON parsing error";
+        case VectorStoreError::FILE_IO_ERROR: return "File I/O error";
+        case VectorStoreError::UNKNOWN_ERROR: return "Unknown error";
+        // JSON specific errors
+        case VectorStoreError::JSON_CAPACITY: return "JSON parser capacity exceeded";
+        case VectorStoreError::JSON_TAPE_ERROR: return "JSON tape error";
+        case VectorStoreError::JSON_DEPTH_ERROR: return "JSON depth error";
+        case VectorStoreError::JSON_STRING_ERROR: return "JSON string error";
+        case VectorStoreError::JSON_T_ATOM_ERROR: return "JSON 'true' atom error";
+        case VectorStoreError::JSON_F_ATOM_ERROR: return "JSON 'false' atom error";
+        case VectorStoreError::JSON_N_ATOM_ERROR: return "JSON 'null' atom error";
+        case VectorStoreError::JSON_NUMBER_ERROR: return "JSON number error";
+        case VectorStoreError::JSON_UTF8_ERROR: return "JSON UTF-8 error";
+        case VectorStoreError::JSON_UNINITIALIZED: return "JSON parser uninitialized";
+        case VectorStoreError::JSON_EMPTY: return "JSON document empty";
+        case VectorStoreError::JSON_UNESCAPED_CHARS: return "JSON unescaped characters";
+        case VectorStoreError::JSON_UNCLOSED_STRING: return "JSON unclosed string";
+        case VectorStoreError::JSON_UNSUPPORTED_ARCHITECTURE: return "JSON unsupported architecture";
+        case VectorStoreError::JSON_INCORRECT_TYPE: return "JSON incorrect type";
+        case VectorStoreError::JSON_NUMBER_OUT_OF_RANGE: return "JSON number out of range";
+        case VectorStoreError::JSON_INDEX_OUT_OF_BOUNDS: return "JSON index out of bounds";
+        case VectorStoreError::JSON_NO_SUCH_FIELD: return "JSON field not found";
+        case VectorStoreError::JSON_IO_ERROR: return "JSON I/O error";
+        case VectorStoreError::JSON_INVALID_JSON_POINTER: return "JSON invalid pointer";
+        case VectorStoreError::JSON_INVALID_URI_FRAGMENT: return "JSON invalid URI fragment";
+        case VectorStoreError::JSON_UNEXPECTED_ERROR: return "JSON unexpected error";
+        case VectorStoreError::JSON_PARSER_IN_USE: return "JSON parser in use";
+        case VectorStoreError::JSON_OUT_OF_ORDER_ITERATION: return "JSON out of order iteration";
+        case VectorStoreError::JSON_INSUFFICIENT_PADDING: return "JSON insufficient padding";
+        case VectorStoreError::JSON_INCOMPLETE_ARRAY_OR_OBJECT: return "JSON incomplete array or object";
+        case VectorStoreError::JSON_SCALAR_DOCUMENT_AS_VALUE: return "JSON scalar document as value";
+        case VectorStoreError::JSON_OUT_OF_BOUNDS: return "JSON out of bounds";
+        case VectorStoreError::JSON_TRAILING_CONTENT: return "JSON trailing content";
+        default: return "Unknown error";
+    }
+}
+
 class ArenaAllocator {
     static constexpr size_t CHUNK_SIZE = 1 << 26;  // 64MB chunks
     struct Chunk {
@@ -31,6 +163,7 @@ public:
     ~ArenaAllocator();
 };
 
+
 struct Document {
     std::string_view id;
     std::string_view text;
@@ -69,6 +202,9 @@ private:
     const size_t dim_;
     ArenaAllocator arena_;
     
+    // Per-thread arena allocators for zero-contention parallel allocation
+    std::vector<std::unique_ptr<ArenaAllocator>> thread_arenas_;
+    
     std::vector<Entry> entries_;
     std::atomic<size_t> count_{0};  // Atomic for parallel loading
     std::atomic<bool> is_finalized_{false};  // Simple flag: false = loading, true = serving
@@ -82,9 +218,31 @@ public:
     explicit VectorStore(size_t dim);
     
     // Overload for document type (used in test_main.cpp)
-    simdjson::error_code add_document(simdjson::ondemand::document& json_doc);
+    VectorStoreError add_document(simdjson::ondemand::document& json_doc);
+    
+    VectorStoreError add_document(simdjson::ondemand::object& json_doc);
+    
+    // Batch processing with index reservation
+    // Thread-local state for batched operations
+    struct BatchState {
+        size_t batch_size;
+        size_t batch_start;
+        size_t batch_offset;
+        
+        BatchState(size_t size = 128) : batch_size(size), batch_start(0), batch_offset(0) {}
+        
+        size_t reserve_next(std::atomic<size_t>& count) {
+            if (batch_offset >= batch_size) {
+                // Need new batch
+                batch_start = count.fetch_add(batch_size, std::memory_order_relaxed);
+                batch_offset = 0;
+            }
+            return batch_start + batch_offset++;
+        }
+    };
     
-    simdjson::error_code add_document(simdjson::ondemand::object& json_doc);
+    // Get thread-local batch state
+    static BatchState& get_batch_state();
     
     // Finalize the store: normalize and switch to serving phase
     void finalize();

package/src/vector_store_loader.cpp

@@ -92,13 +92,16 @@ void VectorStoreLoader::loadDirectory(VectorStore* store, const std::string& pat
     
     for (size_t w = 0; w < num_workers; ++w) {
         consumers.emplace_back([&]() {
-            // Each thread needs its own parser
-            simdjson::ondemand::parser doc_parser;
+            // Each thread needs its own parser with initial capacity
+            simdjson::ondemand::parser doc_parser(16 * 1024 * 1024); // 16MB initial capacity
+            // Set a larger maximum capacity for very large files (up to 512MB)
+            doc_parser.allocate(512 * 1024 * 1024);
             FileData* data = nullptr;
             
             while (true) {
                 // Try to get work from queue
                 if (queue.try_pop(data)) {
+                    
                     // Process the file
                     simdjson::padded_string json(data->content);
                     
@@ -132,16 +135,18 @@ void VectorStoreLoader::loadDirectory(VectorStore* store, const std::string& pat
                             error = doc_element.get_object().get(obj);
                             if (!error) {
                                 auto add_error = store->add_document(obj);
-                                if (add_error) {
+                                if (add_error != VectorStoreError::SUCCESS) {
                                     fprintf(stderr, "Error adding document from %s: %s\n", 
-                                           data->filename.c_str(), simdjson::error_message(add_error));
-                                    if (add_error == simdjson::NO_SUCH_FIELD) {
+                                           data->filename.c_str(), vector_store_error_message(add_error));
+                                    if (add_error == VectorStoreError::JSON_NO_SUCH_FIELD || add_error == VectorStoreError::MISSING_FIELD) {
                                         fprintf(stderr, "  Expected JSON format: {\"id\": string, \"text\": string, \"metadata\": {\"embedding\": [numbers...]}}\n");
                                         fprintf(stderr, "  Required fields: id, text (or content), metadata.embedding\n");
                                         fprintf(stderr, "  Note: 'embedding' must be inside 'metadata' object\n");
                                         fprintf(stderr, "  Note: 'text' and 'content' are interchangeable (Spring AI compatibility)\n");
-                                    } else if (add_error == simdjson::INCORRECT_TYPE) {
-                                        fprintf(stderr, "  Possible causes: wrong embedding dimensions or store already finalized\n");
+                                    } else if (add_error == VectorStoreError::DIMENSION_MISMATCH) {
+                                        fprintf(stderr, "  Check that all embeddings have the same dimensions\n");
+                                    } else if (add_error == VectorStoreError::STORE_ALREADY_FINALIZED) {
+                                        fprintf(stderr, "  Store has been finalized and cannot accept new documents\n");
                                     }
                                 }
                             }
@@ -152,16 +157,18 @@ void VectorStoreLoader::loadDirectory(VectorStore* store, const std::string& pat
                         error = doc.get_object().get(obj);
                         if (!error) {
                             auto add_error = store->add_document(obj);
-                            if (add_error) {
+                            if (add_error != VectorStoreError::SUCCESS) {
                                 fprintf(stderr, "Error adding document from %s: %s\n", 
-                                       data->filename.c_str(), simdjson::error_message(add_error));
-                                if (add_error == simdjson::NO_SUCH_FIELD) {
+                                       data->filename.c_str(), vector_store_error_message(add_error));
+                                if (add_error == VectorStoreError::JSON_NO_SUCH_FIELD || add_error == VectorStoreError::MISSING_FIELD) {
                                     fprintf(stderr, "  Expected JSON format: {\"id\": string, \"text\": string, \"metadata\": {\"embedding\": [numbers...]}}\n");
                                     fprintf(stderr, "  Required fields: id, text (or content), metadata.embedding\n");
                                     fprintf(stderr, "  Note: 'embedding' must be inside 'metadata' object\n");
                                     fprintf(stderr, "  Note: 'text' and 'content' are interchangeable (Spring AI compatibility)\n");
-                                } else if (add_error == simdjson::INCORRECT_TYPE) {
-                                    fprintf(stderr, "  Possible causes: wrong embedding dimensions or store already finalized\n");
+                                } else if (add_error == VectorStoreError::DIMENSION_MISMATCH) {
+                                    fprintf(stderr, "  Check that all embeddings have the same dimensions\n");
+                                } else if (add_error == VectorStoreError::STORE_ALREADY_FINALIZED) {
+                                    fprintf(stderr, "  Store has been finalized and cannot accept new documents\n");
                                 }
                             }
                         }
@@ -189,4 +196,4 @@ void VectorStoreLoader::loadDirectory(VectorStore* store, const std::string& pat
     
     // Finalize after batch load - normalize and switch to serving phase
     store->finalize();
-}
+}

package/src/vector_store_loader_adaptive.cpp

@@ -132,8 +132,10 @@ void VectorStoreLoader::loadDirectoryAdaptive(VectorStore* store, const std::str
     
     for (size_t w = 0; w < num_workers; ++w) {
         consumers.emplace_back([&]() {
-            // Each thread needs its own parser
-            simdjson::ondemand::parser doc_parser;
+            // Each thread needs its own parser with initial capacity
+            simdjson::ondemand::parser doc_parser(16 * 1024 * 1024); // 16MB initial capacity
+            // Set a larger maximum capacity for very large files (up to 512MB)
+            doc_parser.allocate(512 * 1024 * 1024);
             MixedFileData* data = nullptr;
             
             while (true) {
@@ -144,6 +146,7 @@ void VectorStoreLoader::loadDirectoryAdaptive(VectorStore* store, const std::str
                         ? simdjson::padded_string(data->mmap->data(), data->mmap->size())
                         : simdjson::padded_string(data->content);
                     
+                    
                     // Check if it's an array or object
                     const char* json_start = json.data();
                     while (json_start && *json_start && std::isspace(*json_start)) {
@@ -176,9 +179,9 @@ void VectorStoreLoader::loadDirectoryAdaptive(VectorStore* store, const std::str
                             error = doc_element.get_object().get(obj);
                             if (!error) {
                                 auto add_error = store->add_document(obj);
-                                if (add_error) {
+                                if (add_error != VectorStoreError::SUCCESS) {
                                     fprintf(stderr, "Error adding document from %s: %s\n", 
-                                           data->filename.c_str(), simdjson::error_message(add_error));
+                                           data->filename.c_str(), vector_store_error_message(add_error));
                                 }
                             }
                         }
@@ -188,9 +191,9 @@ void VectorStoreLoader::loadDirectoryAdaptive(VectorStore* store, const std::str
                         error = doc.get_object().get(obj);
                         if (!error) {
                             auto add_error = store->add_document(obj);
-                            if (add_error) {
+                            if (add_error != VectorStoreError::SUCCESS) {
                                 fprintf(stderr, "Error adding document from %s: %s\n", 
-                                       data->filename.c_str(), simdjson::error_message(add_error));
+                                       data->filename.c_str(), vector_store_error_message(add_error));
                             }
                         }
                     }
@@ -217,4 +220,4 @@ void VectorStoreLoader::loadDirectoryAdaptive(VectorStore* store, const std::str
     
     // Finalize after batch load - normalize and switch to serving phase
     store->finalize();
-}
+}

package/src/vector_store_loader_mmap.cpp

@@ -67,13 +67,16 @@ void VectorStoreLoader::loadDirectoryMMap(VectorStore* store, const std::string&
     
     for (size_t w = 0; w < num_workers; ++w) {
         consumers.emplace_back([&]() {
-            // Each thread needs its own parser
-            simdjson::ondemand::parser doc_parser;
+            // Each thread needs its own parser with initial capacity
+            simdjson::ondemand::parser doc_parser(16 * 1024 * 1024); // 16MB initial capacity
+            // Set a larger maximum capacity for very large files (up to 512MB)
+            doc_parser.set_max_capacity(512 * 1024 * 1024);
             MMapFileData* data = nullptr;
             
             while (true) {
                 // Try to get work from queue
                 if (queue.try_pop(data)) {
+                    
                     // Process the memory-mapped file
                     // For mmap, we need to copy to ensure padding
                     simdjson::padded_string json(data->mmap->data(), data->mmap->size());
@@ -110,9 +113,9 @@ void VectorStoreLoader::loadDirectoryMMap(VectorStore* store, const std::string&
                             error = doc_element.get_object().get(obj);
                             if (!error) {
                                 auto add_error = store->add_document(obj);
-                                if (add_error) {
+                                if (add_error != VectorStoreError::SUCCESS) {
                                     fprintf(stderr, "Error adding document from %s: %s\n", 
-                                           data->filename.c_str(), simdjson::error_message(add_error));
+                                           data->filename.c_str(), vector_store_error_message(add_error));
                                 }
                             }
                         }
@@ -122,9 +125,9 @@ void VectorStoreLoader::loadDirectoryMMap(VectorStore* store, const std::string&
                         error = doc.get_object().get(obj);
                         if (!error) {
                             auto add_error = store->add_document(obj);
-                            if (add_error) {
+                            if (add_error != VectorStoreError::SUCCESS) {
                                 fprintf(stderr, "Error adding document from %s: %s\n", 
-                                       data->filename.c_str(), simdjson::error_message(add_error));
+                                       data->filename.c_str(), vector_store_error_message(add_error));
                             }
                         }
                     }