fix(vec0): lock incremental persistence and registry

Snapshot HNSW nodes under read lock before incremental SQLite
serialization, and key the vec0 registry by (db, schema, table)
instead of table name alone to prevent cross-connection collisions.

Author: trvon

include/sqlite-vec-cpp/index/hnsw.hpp

@@ -1176,6 +1176,22 @@ template <concepts::VectorElement StorageT, typename MetricT> class HNSWIndex {
         }
     }
 
+    /// Copy a selected set of nodes under the nodes read lock.
+    [[nodiscard]] std::vector<NodeType>
+    snapshotPersistableNodes(std::span<const size_t> node_ids) const {
+        std::shared_lock nodes_lock(nodes_mutex_);
+        std::vector<NodeType> snapshot;
+        snapshot.reserve(node_ids.size());
+        for (size_t node_id : node_ids) {
+            auto it = nodes_.find(node_id);
+            if (it == nodes_.end()) {
+                continue;
+            }
+            snapshot.push_back(it->second);
+        }
+        return snapshot;
+    }
+
     /// Monotonically increasing counter, bumped on every insert/delete.
     /// Used by HNSWQuantizedSearch to detect stale quantization snapshots.
     [[nodiscard]] uint64_t mutation_generation() const {

include/sqlite-vec-cpp/index/hnsw_persistence.hpp

@@ -613,24 +613,21 @@ int save_hnsw_nodes_incremental(sqlite3* db, const char* schema, const char* tab
         return rc;
     }
 
-    for (size_t node_id : nodes_to_save) {
-        const typename HNSWIndex<T, Metric>::NodeType* node = index.get_node(node_id);
-        if (!node) {
-            continue;
-        }
+    const auto node_snapshot = index.snapshotPersistableNodes(nodes_to_save);
 
-        auto node_blob = serialize_hnsw_node(*node);
+    for (const auto& node : node_snapshot) {
+        auto node_blob = serialize_hnsw_node(node);
 
         sqlite3_reset(stmt);
-        sqlite3_bind_int64(stmt, 1, node_id);
+        sqlite3_bind_int64(stmt, 1, node.id);
         sqlite3_bind_blob(stmt, 2, node_blob.data(), node_blob.size(), SQLITE_TRANSIENT);
 
         rc = sqlite3_step(stmt);
         if (rc != SQLITE_DONE) {
             sqlite3_finalize(stmt);
             sqlite3_exec(db, "ROLLBACK", nullptr, nullptr, nullptr);
             if (pzErr)
-                *pzErr = sqlite3_mprintf("Failed to save HNSW node %zu", node_id);
+                *pzErr = sqlite3_mprintf("Failed to save HNSW node %zu", node.id);
             return rc;
         }
     }

include/sqlite-vec-cpp/sqlite/vec0_module.hpp

@@ -77,20 +77,29 @@ inline std::mutex& vec0_registry_mutex() {
     static std::mutex m;
     return m;
 }
-inline void vec0_registry_put(const std::string& key, Vec0Table* t) {
+inline std::string vec0_registry_key(sqlite3* db, std::string_view schema_name,
+                                     std::string_view table_name) {
+    std::ostringstream key;
+    key << static_cast<const void*>(db) << '|' << schema_name << '|' << table_name;
+    return key.str();
+}
+inline void vec0_registry_put(sqlite3* db, std::string_view schema_name,
+                              std::string_view table_name, Vec0Table* t) {
     std::lock_guard<std::mutex> lk(vec0_registry_mutex());
-    vec0_table_registry()[key] = t;
+    vec0_table_registry()[vec0_registry_key(db, schema_name, table_name)] = t;
 }
-inline void vec0_registry_remove(const std::string& key) {
+inline void vec0_registry_remove(sqlite3* db, std::string_view schema_name,
+                                 std::string_view table_name) {
     std::lock_guard<std::mutex> lk(vec0_registry_mutex());
-    vec0_table_registry().erase(key);
+    vec0_table_registry().erase(vec0_registry_key(db, schema_name, table_name));
 }
 template <typename Fn>
-inline auto vec0_with_table(sqlite3* /*db*/, const std::string& table_name, Fn&& fn)
+inline auto vec0_with_table(sqlite3* db, std::string_view schema_name,
+                            std::string_view table_name, Fn&& fn)
     -> decltype(fn(static_cast<Vec0Table*>(nullptr))) {
     std::lock_guard<std::mutex> lk(vec0_registry_mutex());
     auto& reg = vec0_table_registry();
-    auto it = reg.find(table_name);
+    auto it = reg.find(vec0_registry_key(db, schema_name, table_name));
     if (it == reg.end()) {
         return fn(nullptr);
     }
@@ -618,7 +627,7 @@ inline int vec0Create(sqlite3* db, void* pAux, int argc, const char* const* argv
     }
 
     *ppVTab = &table->base;
-    vec0_registry_put(table->table_name, table);
+    vec0_registry_put(table->db, table->schema_name, table->table_name, table);
     return SQLITE_OK;
 }
 
@@ -633,15 +642,15 @@ inline int vec0Connect(sqlite3* db, void* pAux, int argc, const char* const* arg
 // xDisconnect: Called when disconnecting from table
 inline int vec0Disconnect(sqlite3_vtab* pVTab) {
     auto* table = reinterpret_cast<Vec0Table*>(pVTab);
-    vec0_registry_remove(table->table_name);
+    vec0_registry_remove(table->db, table->schema_name, table->table_name);
     delete table;
     return SQLITE_OK;
 }
 
 // xDestroy: Called when DROP TABLE is executed
 inline int vec0Destroy(sqlite3_vtab* pVTab) {
     auto* table = reinterpret_cast<Vec0Table*>(pVTab);
-    vec0_registry_remove(table->table_name);
+    vec0_registry_remove(table->db, table->schema_name, table->table_name);
 
     // Drop shadow tables
     std::ostringstream drop_meta;