@nicia-ai/typegraph 0.28.0 → 0.29.0

package/dist/{chunk-33K3ZYFG.cjs → chunk-RU5BBUU2.cjs}

@@ -1,9 +1,10 @@
 'use strict';
 
-var chunk2E4VTD2E_cjs = require('./chunk-2E4VTD2E.cjs');
-var chunkLYRUNG6E_cjs = require('./chunk-LYRUNG6E.cjs');
-var chunkPN37HVAV_cjs = require('./chunk-PN37HVAV.cjs');
-var chunkYEDQLNVE_cjs = require('./chunk-YEDQLNVE.cjs');
+var chunkZYQEXGYC_cjs = require('./chunk-ZYQEXGYC.cjs');
+var chunkF2Q76CQ4_cjs = require('./chunk-F2Q76CQ4.cjs');
+var chunkRP7YITHX_cjs = require('./chunk-RP7YITHX.cjs');
+var chunkC2RWFIYP_cjs = require('./chunk-C2RWFIYP.cjs');
+var chunkG6P3OVDY_cjs = require('./chunk-G6P3OVDY.cjs');
 var drizzleOrm = require('drizzle-orm');
 var sqliteCore = require('drizzle-orm/sqlite-core');
 
@@ -70,7 +71,7 @@ function resolveSqliteClient(db) {
   return sqliteClient;
 }
 function getOrCreatePreparedStatement(cache, sqliteClient, sqlText, cacheMax) {
-  return chunk2E4VTD2E_cjs.getOrCreateLru(
+  return chunkZYQEXGYC_cjs.getOrCreateLru(
     cache,
     sqlText,
     cacheMax,
@@ -106,7 +107,7 @@ function createSqliteExecutionAdapter(db, statementCacheMaxOrOptions = {}) {
     supportsCompiledExecution: sqliteClient !== void 0,
     transactionMode
   };
-  const compile = (query) => chunk2E4VTD2E_cjs.compileQueryWithDialect(db, query, "SQLite");
+  const compile = (query) => chunkZYQEXGYC_cjs.compileQueryWithDialect(db, query, "SQLite");
   if (sqliteClient !== void 0) {
     let executeCompiled2 = function(compiledQuery) {
       const preparedStatement = getOrCreatePreparedStatement(
@@ -177,10 +178,12 @@ var SQLITE_CHECK_UNIQUE_BATCH_CHUNK_SIZE = Math.max(
   1,
   SQLITE_MAX_BIND_PARAMETERS - CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT
 );
-var toNodeRow = chunk2E4VTD2E_cjs.createNodeRowMapper(chunk2E4VTD2E_cjs.SQLITE_ROW_MAPPER_CONFIG);
-var toEdgeRow = chunk2E4VTD2E_cjs.createEdgeRowMapper(chunk2E4VTD2E_cjs.SQLITE_ROW_MAPPER_CONFIG);
-var toUniqueRow = chunk2E4VTD2E_cjs.createUniqueRowMapper(chunk2E4VTD2E_cjs.SQLITE_ROW_MAPPER_CONFIG);
-var toSchemaVersionRow = chunk2E4VTD2E_cjs.createSchemaVersionRowMapper(chunk2E4VTD2E_cjs.SQLITE_ROW_MAPPER_CONFIG);
+var toNodeRow = chunkZYQEXGYC_cjs.createNodeRowMapper(chunkZYQEXGYC_cjs.SQLITE_ROW_MAPPER_CONFIG);
+var toEdgeRow = chunkZYQEXGYC_cjs.createEdgeRowMapper(chunkZYQEXGYC_cjs.SQLITE_ROW_MAPPER_CONFIG);
+var toUniqueRow = chunkZYQEXGYC_cjs.createUniqueRowMapper(chunkZYQEXGYC_cjs.SQLITE_ROW_MAPPER_CONFIG);
+var toSchemaVersionRow = chunkZYQEXGYC_cjs.createSchemaVersionRowMapper(
+  chunkZYQEXGYC_cjs.SQLITE_ROW_MAPPER_CONFIG
+);
 var PENDING_FOREVER = new Promise(noop);
 function pendingForever() {
   return PENDING_FOREVER;
@@ -198,7 +201,7 @@ function createSerializedExecutionQueue() {
       disposed = true;
     },
     runExclusive(task) {
-      if (isDisposed()) return Promise.reject(new chunkYEDQLNVE_cjs.BackendDisposedError());
+      if (isDisposed()) return Promise.reject(new chunkG6P3OVDY_cjs.BackendDisposedError());
       const runTask = async () => {
         if (isDisposed()) return pendingForever();
         try {
@@ -221,29 +224,19 @@ function runWithSerializedQueue(queue, task) {
   if (queue === void 0) return task();
   return queue.runExclusive(task);
 }
-var SQLITE_VECTOR_METRICS = ["cosine", "l2"];
-var SQLITE_VECTOR_INDEX_TYPES = ["none"];
-var SQLITE_VECTOR_MAX_DIMENSIONS = 8e3;
 function throwSqliteTransactionsDisabled(message) {
-  throw new chunkYEDQLNVE_cjs.ConfigurationError(message, {
+  throw new chunkG6P3OVDY_cjs.ConfigurationError(message, {
     backend: "sqlite",
     capability: "transactions",
     supportsTransactions: false
   });
 }
 function buildSqliteCapabilities(options) {
-  const base = options.transactionMode === "none" ? { ...chunkLYRUNG6E_cjs.SQLITE_CAPABILITIES, transactions: false } : chunkLYRUNG6E_cjs.SQLITE_CAPABILITIES;
+  const base = options.transactionMode === "none" ? { ...chunkF2Q76CQ4_cjs.SQLITE_CAPABILITIES, transactions: false } : chunkF2Q76CQ4_cjs.SQLITE_CAPABILITIES;
   return {
     ...base,
-    fulltext: chunkPN37HVAV_cjs.buildFulltextCapabilities(options.fulltextStrategy),
-    ...options.hasVectorEmbeddings ? {
-      vector: {
-        supported: true,
-        metrics: SQLITE_VECTOR_METRICS,
-        indexTypes: SQLITE_VECTOR_INDEX_TYPES,
-        maxDimensions: SQLITE_VECTOR_MAX_DIMENSIONS
-      }
-    } : {}
+    fulltext: chunkC2RWFIYP_cjs.buildFulltextCapabilities(options.fulltextStrategy),
+    ...options.vectorStrategy === void 0 ? {} : { vector: chunkC2RWFIYP_cjs.buildVectorCapabilities(options.vectorStrategy) }
   };
 }
 function createSqliteOperationBackend(options) {
@@ -254,7 +247,9 @@ function createSqliteOperationBackend(options) {
     operationStrategy,
     serializedQueue,
     tableNames,
-    fulltextStrategy
+    fulltextStrategy,
+    vectorStrategy,
+    vectorSlotLatch
   } = options;
   function execGet(query) {
     return runWithSerializedQueue(serializedQueue, async () => {
@@ -272,7 +267,7 @@ function createSqliteOperationBackend(options) {
       await db.run(query);
     });
   }
-  const commonBackend = chunk2E4VTD2E_cjs.createCommonOperationBackend({
+  const commonBackend = chunkZYQEXGYC_cjs.createCommonOperationBackend({
     batchConfig: {
       checkUniqueBatchChunkSize: SQLITE_CHECK_UNIQUE_BATCH_CHUNK_SIZE,
       edgeInsertBatchSize: SQLITE_EDGE_INSERT_BATCH_SIZE,
@@ -285,7 +280,7 @@ function createSqliteOperationBackend(options) {
       execGet,
       execRun
     },
-    nowIso: chunk2E4VTD2E_cjs.nowIso,
+    nowIso: chunkZYQEXGYC_cjs.nowIso,
     operationStrategy,
     rowMappers: {
       toEdgeRow,
@@ -303,29 +298,50 @@ function createSqliteOperationBackend(options) {
       );
     }
   };
-  const vectorEmbeddingMethods = options.hasVectorEmbeddings ? {
+  async function ensureVectorSlotStorage(slot) {
+    if (vectorStrategy === void 0 || vectorSlotLatch === void 0) return;
+    await vectorSlotLatch.ensure(vectorStrategy, slot, async (statement) => {
+      await execRun(drizzleOrm.sql.raw(statement));
+    });
+  }
+  const vectorEmbeddingMethods = vectorStrategy === void 0 ? {} : {
     async upsertEmbedding(params) {
-      const query = operationStrategy.buildUpsertEmbedding(
-        params,
-        chunk2E4VTD2E_cjs.nowIso()
-      );
-      await execRun(query);
+      const slot = chunkZYQEXGYC_cjs.vectorSlotFromParams(params);
+      await ensureVectorSlotStorage(slot);
+      const statements = vectorStrategy.buildUpsert(slot, params, chunkZYQEXGYC_cjs.nowIso());
+      try {
+        for (const statement of statements) {
+          await execRun(statement);
+        }
+      } catch (error) {
+        throw chunkZYQEXGYC_cjs.mapVectorWriteError(error, params);
+      }
     },
     async deleteEmbedding(params) {
-      const query = operationStrategy.buildDeleteEmbedding(params);
-      await execRun(query);
+      const slot = chunkZYQEXGYC_cjs.vectorSlotFromParams(params);
+      await ensureVectorSlotStorage(slot);
+      const statements = vectorStrategy.buildDelete(slot, params);
+      for (const statement of statements) {
+        await execRun(statement);
+      }
     },
     async vectorSearch(params) {
-      const query = operationStrategy.buildVectorSearch(params);
-      const rows = await execAll(
-        query
-      );
+      chunkC2RWFIYP_cjs.assertVectorSearchLimit(params.limit);
+      const slot = chunkZYQEXGYC_cjs.vectorSlotFromParams(params);
+      await ensureVectorSlotStorage(slot);
+      const query = vectorStrategy.buildSearch(slot, params);
+      let rows;
+      try {
+        rows = await execAll(query);
+      } catch (error) {
+        throw chunkZYQEXGYC_cjs.mapVectorWriteError(error, params);
+      }
       return rows.map((row) => ({
         nodeId: row.node_id,
         score: row.score
       }));
     }
-  } : {};
+  };
   const operationBackend = {
     ...commonBackend,
     ...executeRawMethod,
@@ -334,38 +350,30 @@ function createSqliteOperationBackend(options) {
     dialect: "sqlite",
     tableNames,
     fulltextStrategy,
-    createVectorIndex(params) {
-      const indexOptions = {
-        graphId: params.graphId,
-        nodeKind: params.nodeKind,
-        fieldPath: params.fieldPath,
-        dimensions: params.dimensions,
-        indexType: params.indexType,
-        metric: params.metric,
-        ...params.indexParams?.m === void 0 ? {} : { hnswM: params.indexParams.m },
-        ...params.indexParams?.efConstruction === void 0 ? {} : { hnswEfConstruction: params.indexParams.efConstruction },
-        ...params.indexParams?.lists === void 0 ? {} : { ivfflatLists: params.indexParams.lists }
-      };
-      const result = chunk2E4VTD2E_cjs.createSqliteVectorIndex(indexOptions);
-      if (!result.success) {
-        throw new Error(result.message ?? "Failed to create SQLite vector index");
+    ...vectorStrategy === void 0 ? {} : { vectorStrategy },
+    async createVectorIndex(params) {
+      if (vectorStrategy === void 0) return;
+      const slot = chunkZYQEXGYC_cjs.vectorSlotFromCreateIndexParams(params);
+      await ensureVectorSlotStorage(slot);
+      const indexStatement = vectorStrategy.buildCreateIndex?.(slot);
+      if (indexStatement !== void 0) {
+        await execRun(indexStatement);
       }
-      return Promise.resolve();
     },
-    dropVectorIndex(params) {
-      const result = chunk2E4VTD2E_cjs.dropSqliteVectorIndex(
-        params.graphId,
-        params.nodeKind,
-        params.fieldPath
-      );
-      if (!result.success) {
-        throw new Error(result.message ?? "Failed to drop SQLite vector index");
+    async dropVectorIndex(params) {
+      if (vectorStrategy === void 0) return;
+      const slot = chunkZYQEXGYC_cjs.vectorSlotFromDropIndexParams(params);
+      const dropStatement = vectorStrategy.buildDropIndex?.(slot);
+      if (dropStatement === void 0) return;
+      try {
+        await execRun(dropStatement);
+      } catch (error) {
+        if (!chunkRP7YITHX_cjs.isMissingTableError(error)) throw error;
       }
-      return Promise.resolve();
     },
     // === Fulltext Operations ===
     async upsertFulltext(params) {
-      const timestamp = chunk2E4VTD2E_cjs.nowIso();
+      const timestamp = chunkZYQEXGYC_cjs.nowIso();
       const statements = operationStrategy.buildUpsertFulltext(
         params,
         timestamp
@@ -382,7 +390,7 @@ function createSqliteOperationBackend(options) {
     },
     async upsertFulltextBatch(params) {
       if (params.rows.length === 0) return;
-      const timestamp = chunk2E4VTD2E_cjs.nowIso();
+      const timestamp = chunkZYQEXGYC_cjs.nowIso();
       const statements = operationStrategy.buildUpsertFulltextBatch(
         params,
         timestamp
@@ -403,7 +411,7 @@ function createSqliteOperationBackend(options) {
       const rows = await execAll(query);
       return rows.map((row, index) => ({
         nodeId: row.node_id,
-        score: chunk2E4VTD2E_cjs.coerceNumericScore(row.score),
+        score: chunkZYQEXGYC_cjs.coerceNumericScore(row.score),
         rank: index + 1,
         ...row.snippet === null ? {} : { snippet: row.snippet }
       }));
@@ -422,25 +430,25 @@ function createSqliteOperationBackend(options) {
   return operationBackend;
 }
 function createSqliteBackend(db, options = {}) {
-  const tables2 = options.tables ?? chunk2E4VTD2E_cjs.tables2;
-  const fulltextStrategy = options.fulltext ?? chunkPN37HVAV_cjs.fts5Strategy;
+  const tables2 = options.tables ?? chunkF2Q76CQ4_cjs.tables;
+  const fulltextStrategy = options.fulltext ?? chunkC2RWFIYP_cjs.fts5Strategy;
   const profileHints = options.executionProfile ?? {};
   const executionAdapter = createSqliteExecutionAdapter(db, { profileHints });
   const { isSync, transactionMode } = executionAdapter.profile;
-  const hasVectorEmbeddings = options.hasVectorEmbeddings === true;
+  const vectorStrategy = options.vector;
+  const vectorSlotLatch = vectorStrategy === void 0 ? void 0 : chunkZYQEXGYC_cjs.createVectorSlotLatch();
   const capabilities = buildSqliteCapabilities({
     fulltextStrategy,
-    hasVectorEmbeddings,
+    vectorStrategy,
     transactionMode
   });
   const tableNames = {
     nodes: drizzleOrm.getTableName(tables2.nodes),
     edges: drizzleOrm.getTableName(tables2.edges),
-    embeddings: drizzleOrm.getTableName(tables2.embeddings),
     fulltext: tables2.fulltextTableName,
     uniques: drizzleOrm.getTableName(tables2.uniques)
   };
-  const operationStrategy = chunk2E4VTD2E_cjs.createSqliteOperationStrategy(
+  const operationStrategy = chunkZYQEXGYC_cjs.createSqliteOperationStrategy(
     tables2,
     fulltextStrategy
   );
@@ -452,7 +460,8 @@ function createSqliteBackend(db, options = {}) {
     operationStrategy,
     tableNames,
     fulltextStrategy,
-    hasVectorEmbeddings,
+    vectorStrategy,
+    vectorSlotLatch,
     ...serializedQueue === void 0 ? {} : { serializedQueue }
   });
   function runDoSqliteStorageTransaction(run) {
@@ -484,8 +493,7 @@ function createSqliteBackend(db, options = {}) {
           profileHints: { isSync: true },
           tableNames,
           fulltextStrategy,
-          hasVectorEmbeddings
-        });
+          vectorStrategy});
         db.run(drizzleOrm.sql`BEGIN IMMEDIATE`);
         try {
           const result = await fn(txBackend);
@@ -506,30 +514,31 @@ function createSqliteBackend(db, options = {}) {
           profileHints: { isSync },
           tableNames,
           fulltextStrategy,
-          hasVectorEmbeddings
-        });
+          vectorStrategy});
         return fn(txBackend);
       });
     }
     return runWithSerializedQueue(
       serializedQueue,
-      async () => db.transaction(async (tx) => {
-        const txBackend = createTransactionBackend({
-          capabilities,
-          db: tx,
-          operationStrategy,
-          profileHints: { isSync },
-          tableNames,
-          fulltextStrategy,
-          hasVectorEmbeddings
-        });
-        return fn(txBackend);
-      }, { behavior: "immediate" })
+      async () => db.transaction(
+        async (tx) => {
+          const txBackend = createTransactionBackend({
+            capabilities,
+            db: tx,
+            operationStrategy,
+            profileHints: { isSync },
+            tableNames,
+            fulltextStrategy,
+            vectorStrategy});
+          return fn(txBackend);
+        },
+        { behavior: "immediate" }
+      )
     );
   }
   const matTable = tables2.contributionMaterializations;
   async function ensureContributionMaterializationsTableImpl() {
-    await db.run(drizzleOrm.sql.raw(chunk2E4VTD2E_cjs.generateSqliteCreateTableSQL(matTable)));
+    await db.run(drizzleOrm.sql.raw(chunkZYQEXGYC_cjs.generateSqliteCreateTableSQL(matTable)));
   }
   async function getContributionMaterializationRow(identity) {
     const rows = await db.select().from(matTable).where(
@@ -542,16 +551,16 @@ function createSqliteBackend(db, options = {}) {
     );
     const row = rows[0];
     if (row === void 0) return void 0;
-    return chunk2E4VTD2E_cjs.mapContributionMaterializationRow(
+    return chunkZYQEXGYC_cjs.mapContributionMaterializationRow(
       row,
-      chunk2E4VTD2E_cjs.SQLITE_CONTRIBUTION_MAT_TIMESTAMPS.decode
+      chunkZYQEXGYC_cjs.SQLITE_CONTRIBUTION_MAT_TIMESTAMPS.decode
     );
   }
   async function recordContributionMaterializationRow(params) {
     await db.insert(matTable).values(
-      chunk2E4VTD2E_cjs.buildContributionInsertValues(
+      chunkZYQEXGYC_cjs.buildContributionInsertValues(
         params,
-        chunk2E4VTD2E_cjs.SQLITE_CONTRIBUTION_MAT_TIMESTAMPS.encode
+        chunkZYQEXGYC_cjs.SQLITE_CONTRIBUTION_MAT_TIMESTAMPS.encode
       )
     ).onConflictDoUpdate({
       target: [
@@ -560,13 +569,13 @@ function createSqliteBackend(db, options = {}) {
         matTable.owner,
         matTable.tableName
       ],
-      set: chunk2E4VTD2E_cjs.buildContributionOnConflictSet(
+      set: chunkZYQEXGYC_cjs.buildContributionOnConflictSet(
         matTable.materializedAt,
         params.materializedAt
       )
     });
   }
-  const contributionMaterializer = chunk2E4VTD2E_cjs.createContributionMaterializer({
+  const contributionMaterializer = chunkZYQEXGYC_cjs.createContributionMaterializer({
     dialect: "sqlite",
     fulltextStrategy,
     fulltextTableName: tables2.fulltextTableName,
@@ -585,14 +594,13 @@ function createSqliteBackend(db, options = {}) {
       profileHints: { isSync },
       tableNames,
       fulltextStrategy,
-      hasVectorEmbeddings
-    });
-    return chunk2E4VTD2E_cjs.gateFulltext(txBackend, contributionMaterializer.assertInitialized);
+      vectorStrategy});
+    return chunkZYQEXGYC_cjs.gateFulltext(txBackend, contributionMaterializer.assertInitialized);
   }
   const backend = {
     ...operations,
     async bootstrapTables() {
-      const statements = chunk2E4VTD2E_cjs.generateSqliteDDL(tables2, fulltextStrategy);
+      const statements = chunkZYQEXGYC_cjs.generateSqliteDDL(tables2, fulltextStrategy);
       for (const statement of statements) {
         await db.run(drizzleOrm.sql.raw(statement));
       }
@@ -602,7 +610,7 @@ function createSqliteBackend(db, options = {}) {
     // uninitialized database throws `StoreNotInitializedError` rather
     // than self-healing (#135). Shared verbatim with the tx-scoped gate
     // via `gateFulltextMethods`.
-    ...chunk2E4VTD2E_cjs.gateFulltextMethods(
+    ...chunkZYQEXGYC_cjs.gateFulltextMethods(
       operations,
       contributionMaterializer.assertInitialized
     ),
@@ -611,7 +619,7 @@ function createSqliteBackend(db, options = {}) {
     },
     async ensureIndexMaterializationsTable() {
       await db.run(
-        drizzleOrm.sql.raw(chunk2E4VTD2E_cjs.generateSqliteCreateTableSQL(tables2.indexMaterializations))
+        drizzleOrm.sql.raw(chunkZYQEXGYC_cjs.generateSqliteCreateTableSQL(tables2.indexMaterializations))
       );
     },
     async getIndexMaterialization(indexName) {
@@ -619,26 +627,26 @@ function createSqliteBackend(db, options = {}) {
       const rows = await db.select().from(t).where(drizzleOrm.eq(t.indexName, indexName));
       const row = rows[0];
       if (row === void 0) return void 0;
-      return chunk2E4VTD2E_cjs.mapMaterializationRow(row, chunk2E4VTD2E_cjs.SQLITE_INDEX_MAT_TIMESTAMPS.decode);
+      return chunkZYQEXGYC_cjs.mapMaterializationRow(row, chunkZYQEXGYC_cjs.SQLITE_INDEX_MAT_TIMESTAMPS.decode);
     },
     async getIndexMaterializations(statusKeys) {
       if (statusKeys.length === 0) return [];
       const t = tables2.indexMaterializations;
       const rows = await db.select().from(t).where(drizzleOrm.inArray(t.indexName, [...statusKeys]));
       return rows.map(
-        (row) => chunk2E4VTD2E_cjs.mapMaterializationRow(row, chunk2E4VTD2E_cjs.SQLITE_INDEX_MAT_TIMESTAMPS.decode)
+        (row) => chunkZYQEXGYC_cjs.mapMaterializationRow(row, chunkZYQEXGYC_cjs.SQLITE_INDEX_MAT_TIMESTAMPS.decode)
       );
     },
     async recordIndexMaterialization(params) {
       const t = tables2.indexMaterializations;
       await db.insert(t).values(
-        chunk2E4VTD2E_cjs.buildMaterializationInsertValues(
+        chunkZYQEXGYC_cjs.buildMaterializationInsertValues(
           params,
-          chunk2E4VTD2E_cjs.SQLITE_INDEX_MAT_TIMESTAMPS.encode
+          chunkZYQEXGYC_cjs.SQLITE_INDEX_MAT_TIMESTAMPS.encode
         )
       ).onConflictDoUpdate({
         target: t.indexName,
-        set: chunk2E4VTD2E_cjs.buildMaterializationOnConflictSet(
+        set: chunkZYQEXGYC_cjs.buildMaterializationOnConflictSet(
           t.materializedAt,
           params.materializedAt
         )
@@ -657,37 +665,37 @@ function createSqliteBackend(db, options = {}) {
       await contributionMaterializer.assertInitialized(graphId);
     },
     async ensureKindRemovalsTable() {
-      await db.run(drizzleOrm.sql.raw(chunk2E4VTD2E_cjs.generateSqliteCreateTableSQL(tables2.kindRemovals)));
+      await db.run(drizzleOrm.sql.raw(chunkZYQEXGYC_cjs.generateSqliteCreateTableSQL(tables2.kindRemovals)));
     },
     async getPendingKindRemovals(graphId) {
       const t = tables2.kindRemovals;
       const rows = await db.select().from(t).where(drizzleOrm.and(drizzleOrm.eq(t.graphId, graphId), drizzleOrm.isNull(t.removedAt)));
       return rows.map(
-        (row) => chunk2E4VTD2E_cjs.mapKindRemovalRow(row, chunk2E4VTD2E_cjs.SQLITE_KIND_REMOVAL_TIMESTAMPS.decode)
+        (row) => chunkZYQEXGYC_cjs.mapKindRemovalRow(row, chunkZYQEXGYC_cjs.SQLITE_KIND_REMOVAL_TIMESTAMPS.decode)
       );
     },
     async getAllKindRemovals(graphId) {
       const t = tables2.kindRemovals;
       const rows = await db.select().from(t).where(drizzleOrm.eq(t.graphId, graphId));
       return rows.map(
-        (row) => chunk2E4VTD2E_cjs.mapKindRemovalRow(row, chunk2E4VTD2E_cjs.SQLITE_KIND_REMOVAL_TIMESTAMPS.decode)
+        (row) => chunkZYQEXGYC_cjs.mapKindRemovalRow(row, chunkZYQEXGYC_cjs.SQLITE_KIND_REMOVAL_TIMESTAMPS.decode)
       );
     },
     async recordKindRemoval(params) {
       const t = tables2.kindRemovals;
       await db.insert(t).values(
-        chunk2E4VTD2E_cjs.buildKindRemovalInsertValues(
+        chunkZYQEXGYC_cjs.buildKindRemovalInsertValues(
           params,
-          chunk2E4VTD2E_cjs.SQLITE_KIND_REMOVAL_TIMESTAMPS.encode
+          chunkZYQEXGYC_cjs.SQLITE_KIND_REMOVAL_TIMESTAMPS.encode
         )
       ).onConflictDoUpdate({
         target: [t.graphId, t.kindName, t.entity, t.schemaVersion],
-        set: chunk2E4VTD2E_cjs.buildKindRemovalOnConflictSet(t.removedAt, params.removedAt)
+        set: chunkZYQEXGYC_cjs.buildKindRemovalOnConflictSet(t.removedAt, params.removedAt)
       });
     },
     async ensureReconciliationMarkersTable() {
       await db.run(
-        drizzleOrm.sql.raw(chunk2E4VTD2E_cjs.generateSqliteCreateTableSQL(tables2.reconciliationMarkers))
+        drizzleOrm.sql.raw(chunkZYQEXGYC_cjs.generateSqliteCreateTableSQL(tables2.reconciliationMarkers))
       );
     },
     async ensureRuntimeContributions(graphId) {
@@ -742,12 +750,11 @@ function createSqliteBackend(db, options = {}) {
             profileHints: { isSync: true },
             tableNames,
             fulltextStrategy,
-            hasVectorEmbeddings
-          });
+            vectorStrategy});
           db.run(drizzleOrm.sql`BEGIN`);
           try {
             const result = await fn(
-              chunk2E4VTD2E_cjs.gateFulltext(
+              chunkZYQEXGYC_cjs.gateFulltext(
                 txBackend,
                 contributionMaterializer.assertInitialized
               ),
@@ -779,7 +786,7 @@ function createSqliteBackend(db, options = {}) {
           "Cross-store atomicity is unavailable on this SQLite backend: transactions are disabled (transactionMode: 'none'). Adopting an external transaction here would let the caller's relational write commit with no way to roll back the graph write. Configure a driver that supports transactions (better-sqlite3, libsql, bun:sqlite)."
         );
       }
-      chunk2E4VTD2E_cjs.assertAdoptedDialect(
+      chunkZYQEXGYC_cjs.assertAdoptedDialect(
         externalTx,
         sqliteCore.BaseSQLiteDatabase,
         "sqlite"
@@ -804,10 +811,11 @@ function createTransactionBackend(options) {
     operationStrategy: options.operationStrategy,
     tableNames: options.tableNames,
     fulltextStrategy: options.fulltextStrategy,
-    ...options.hasVectorEmbeddings === void 0 ? {} : { hasVectorEmbeddings: options.hasVectorEmbeddings }
+    vectorStrategy: options.vectorStrategy,
+    ...options.vectorStrategy === void 0 ? {} : { vectorSlotLatch: chunkZYQEXGYC_cjs.createVectorSlotLatch() }
   });
 }
 
 exports.createSqliteBackend = createSqliteBackend;
-//# sourceMappingURL=chunk-33K3ZYFG.cjs.map
-//# sourceMappingURL=chunk-33K3ZYFG.cjs.map
+//# sourceMappingURL=chunk-RU5BBUU2.cjs.map
+//# sourceMappingURL=chunk-RU5BBUU2.cjs.map