@nicia-ai/typegraph 0.36.0 → 0.37.0

package/dist/{chunk-BJVEU3ZL.js → chunk-J4IUSYFF.js}

@@ -1,11 +1,11 @@
-import { createVectorSlotLatch, createSqliteOperationStrategy, createContributionMaterializer, gateFulltextMethods, generateSqliteCreateTableSQL, mapContributionMaterializationRow, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, buildContributionInsertValues, buildContributionOnConflictSet, assertAdoptedDialect, buildKindRemovalInsertValues, SQLITE_KIND_REMOVAL_TIMESTAMPS, buildKindRemovalOnConflictSet, mapKindRemovalRow, buildMaterializationInsertValues, SQLITE_INDEX_MAT_TIMESTAMPS, buildMaterializationOnConflictSet, mapMaterializationRow, generateSqliteDDL, createCommonOperationBackend, vectorSlotFromParams, hybridCandidatesRef, mapVectorWriteError, mapHybridSearchRow, gateFulltext, compileQueryWithDialect, EMBEDDING_UPSERT_PARAM_COUNT, vectorSlotFromDropIndexParams, vectorSlotFromCreateIndexParams, getOrCreateLru } from './chunk-4GX2JJXS.js';
-import { tables } from './chunk-VHMPG6UL.js';
-import { createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, quoteIdentifier, nowIso, coerceNumericScore } from './chunk-RAXU3RMB.js';
-import { fts5Strategy, buildVectorCapabilities, buildFulltextCapabilities, assertVectorSearchLimit } from './chunk-FPIZFYHE.js';
-import { SQLITE_CAPABILITIES, SQLITE_MAX_BIND_PARAMETERS, D1_MAX_BIND_PARAMETERS, MODERN_SQLITE_MAX_BIND_PARAMETERS, chunk } from './chunk-IU46OHVW.js';
-import { isMissingTableError } from './chunk-JFUPDJXD.js';
-import { ConfigurationError, BackendDisposedError } from './chunk-WI7ISNQF.js';
-import { getTableName, sql, and, eq, isNull, inArray } from 'drizzle-orm';
+import { createSqliteOperationStrategy, createContributionMaterializer, gateFulltextMethods, assertTrustedImportDatabaseEmpty, suspendSqliteSecondaryIndexes, createSqliteTrustedImportSession, restoreSecondaryIndexes, analyzeImportedTables, generateSqliteCreateTableSQL, mapContributionMaterializationRow, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, buildContributionInsertValues, buildContributionOnConflictSet, assertAdoptedDialect, buildKindRemovalInsertValues, SQLITE_KIND_REMOVAL_TIMESTAMPS, buildKindRemovalOnConflictSet, mapKindRemovalRow, buildMaterializationInsertValues, SQLITE_INDEX_MAT_TIMESTAMPS, buildMaterializationOnConflictSet, mapMaterializationRow, generateSqliteDDL, createCommonOperationBackend, vectorSlotFromParams, hybridCandidatesRef, mapVectorWriteError, mapHybridSearchRow, gateFulltext, compileQueryWithDialect, EMBEDDING_UPSERT_PARAM_COUNT, vectorSlotFromDropIndexParams, vectorSlotFromCreateIndexParams, getOrCreateLru } from './chunk-K3Q3LJY3.js';
+import { tables } from './chunk-UXLSNRYL.js';
+import { createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, quoteIdentifier, nowIso, coerceNumericScore } from './chunk-M6VES7V6.js';
+import { fts5Strategy, buildVectorCapabilities, buildFulltextCapabilities, assertVectorSearchLimit } from './chunk-EXU3RASM.js';
+import { normalizeGraphAnalyticsCapabilities, INTERNAL_TEMPORARY_WRITES, SQLITE_CAPABILITIES, SQLITE_MAX_BIND_PARAMETERS, MODERN_SQLITE_MAX_BIND_PARAMETERS, chunk, DURABLE_OBJECT_MAX_BIND_PARAMETERS, D1_MAX_BIND_PARAMETERS } from './chunk-44TA22QT.js';
+import { isMissingTableError } from './chunk-XGPUQ56G.js';
+import { ConfigurationError, BackendDisposedError } from './chunk-5PNMDJ7J.js';
+import { getTableName, sql, eq, and, isNull, inArray } from 'drizzle-orm';
 import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
 
 var DEFAULT_PREPARED_STATEMENT_CACHE_MAX = 256;
@@ -24,11 +24,30 @@ function isDurableObjectBySessionName(db) {
   const sessionName = getSessionName(db);
   return sessionName === "SQLiteDOSession" || sessionName === "SQLiteDurableObjectSession";
 }
+function isDurableObjectStorageClient(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  const sqlApi = candidate.sql;
+  return typeof candidate.transaction === "function" && typeof candidate.transactionSync === "function" && typeof sqlApi === "object" && sqlApi !== null && typeof sqlApi.exec === "function";
+}
+function getDurableObjectStorageClient(db) {
+  const client = db.$client;
+  return isDurableObjectStorageClient(client) ? client : void 0;
+}
+function detectHostedPlatform(db) {
+  if (getDurableObjectStorageClient(db) !== void 0 || isDurableObjectBySessionName(db)) {
+    return "durable-object";
+  }
+  if (isD1DatabaseBySessionName(db)) return "d1";
+  return void 0;
+}
 function isSyncDatabaseBySessionName(db) {
   const sessionName = getSessionName(db);
   return sessionName === "BetterSQLiteSession" || sessionName === "BunSQLiteSession";
 }
-function detectSyncProfile(db, profileHints) {
+function detectSyncProfile(db, profileHints, hostedPlatform) {
+  if (hostedPlatform === "durable-object") return true;
+  if (hostedPlatform === "d1") return false;
   if (profileHints.isSync !== void 0) {
     return profileHints.isSync;
   }
@@ -36,12 +55,6 @@ function detectSyncProfile(db, profileHints) {
   if (sessionName === "BetterSQLiteSession" || sessionName === "BunSQLiteSession") {
     return true;
   }
-  if (isDurableObjectBySessionName(db)) {
-    return true;
-  }
-  if (sessionName === "SQLiteD1Session") {
-    return false;
-  }
   try {
     const probeResult = db.get(sql`SELECT 1 AS __typegraph_sync_probe__`);
     return !(probeResult instanceof Promise);
@@ -49,16 +62,12 @@ function detectSyncProfile(db, profileHints) {
     return isSyncDatabaseBySessionName(db);
   }
 }
-function detectTransactionMode(db, profileHints, isSync) {
+function detectTransactionMode(profileHints, isSync, hostedPlatform) {
+  if (hostedPlatform === "durable-object") return "do-sqlite";
+  if (hostedPlatform === "d1") return "none";
   if (profileHints.transactionMode !== void 0) {
     return profileHints.transactionMode;
   }
-  if (isDurableObjectBySessionName(db)) {
-    return "do-sqlite";
-  }
-  if (isD1DatabaseBySessionName(db)) {
-    return "none";
-  }
   if (isSync) return "sql";
   return "drizzle";
 }
@@ -84,8 +93,15 @@ function hasModernBindLimitByVersion(rows) {
   if (!Number.isFinite(major) || !Number.isFinite(minor)) return false;
   return major > FIRST_MODERN_BIND_LIMIT_MAJOR || major === FIRST_MODERN_BIND_LIMIT_MAJOR && minor >= FIRST_MODERN_BIND_LIMIT_MINOR;
 }
-function detectMaxBindParameters(db, sqliteClient) {
-  if (isD1DatabaseBySessionName(db)) return D1_MAX_BIND_PARAMETERS;
+function detectHardMaxBindParameters(transactionMode, hostedPlatform) {
+  if (hostedPlatform === "durable-object" || transactionMode === "do-sqlite") {
+    return DURABLE_OBJECT_MAX_BIND_PARAMETERS;
+  }
+  if (hostedPlatform === "d1") return D1_MAX_BIND_PARAMETERS;
+  return void 0;
+}
+function detectMaxBindParameters(sqliteClient, hardMaxBindParameters) {
+  if (hardMaxBindParameters !== void 0) return hardMaxBindParameters;
   if (sqliteClient === void 0) return SQLITE_MAX_BIND_PARAMETERS;
   try {
     const compiled = parseCompiledMaxVariableNumber(
@@ -101,11 +117,10 @@ function detectMaxBindParameters(db, sqliteClient) {
   }
 }
 function resolveSqliteClient(db) {
-  const databaseWithClient = db;
-  const sqliteClient = databaseWithClient.$client;
-  if (sqliteClient?.prepare === void 0) {
-    return void 0;
-  }
+  const sqliteClient = db.$client;
+  if (typeof sqliteClient !== "object" || sqliteClient === null) return;
+  const candidate = sqliteClient;
+  if (typeof candidate.prepare !== "function") return;
   return sqliteClient;
 }
 function getOrCreatePreparedStatement(cache, sqliteClient, sqlText, cacheMax) {
@@ -137,12 +152,27 @@ function createSqliteExecutionAdapter(db, statementCacheMaxOrOptions = {}) {
   const options = typeof statementCacheMaxOrOptions === "number" ? { statementCacheMax: statementCacheMaxOrOptions } : statementCacheMaxOrOptions;
   const statementCacheMax = options.statementCacheMax ?? DEFAULT_PREPARED_STATEMENT_CACHE_MAX;
   const profileHints = options.profileHints ?? {};
-  const isSync = detectSyncProfile(db, profileHints);
+  const hostedPlatform = detectHostedPlatform(db);
+  const isSync = detectSyncProfile(db, profileHints, hostedPlatform);
   const sqliteClient = isSync ? resolveSqliteClient(db) : void 0;
-  const transactionMode = detectTransactionMode(db, profileHints, isSync);
+  const transactionMode = detectTransactionMode(
+    profileHints,
+    isSync,
+    hostedPlatform
+  );
+  const hardMaxBindParameters = detectHardMaxBindParameters(
+    transactionMode,
+    hostedPlatform
+  );
+  const maxBindParameters = detectMaxBindParameters(
+    sqliteClient,
+    hardMaxBindParameters
+  );
   const profile = {
+    ...hostedPlatform === void 0 ? {} : { hostedPlatform },
+    ...hardMaxBindParameters === void 0 ? {} : { hardMaxBindParameters },
     isSync,
-    maxBindParameters: detectMaxBindParameters(db, sqliteClient),
+    maxBindParameters,
     supportsCompiledExecution: sqliteClient !== void 0,
     transactionMode
   };
@@ -170,6 +200,22 @@ function createSqliteExecutionAdapter(db, statementCacheMaxOrOptions = {}) {
         preparedStatement.run(...compiledQuery.params);
       }
       return Promise.resolve();
+    }, executePreparedRunBatch2 = function(sqlText, parameterRows) {
+      const preparedStatement = getOrCreatePreparedStatement(
+        statementCache,
+        client,
+        sqlText,
+        statementCacheMax
+      );
+      if (preparedStatement.run === void 0) {
+        throw new Error(
+          "Trusted SQLite import requires a prepared statement run() method."
+        );
+      }
+      for (const params of parameterRows) {
+        preparedStatement.run(...params);
+      }
+      return Promise.resolve();
     };
     const client = sqliteClient;
     const statementCache = /* @__PURE__ */ new Map();
@@ -184,6 +230,7 @@ function createSqliteExecutionAdapter(db, statementCacheMaxOrOptions = {}) {
       },
       executeCompiled: executeCompiled2,
       executeCompiledRun: executeCompiledRun2,
+      executePreparedRunBatch: executePreparedRunBatch2,
       prepare(sqlText) {
         return createPreparedStatementExecutor(
           client,
@@ -335,7 +382,16 @@ function throwSqliteTransactionsDisabled(message) {
   });
 }
 function buildSqliteCapabilities(options) {
-  const base = options.transactionMode === "none" ? { ...SQLITE_CAPABILITIES, transactions: false } : SQLITE_CAPABILITIES;
+  const base = options.transactionMode === "none" ? {
+    ...SQLITE_CAPABILITIES,
+    transactions: false,
+    graphAnalytics: {
+      ...SQLITE_CAPABILITIES.graphAnalytics ?? {
+        mathFunctions: false
+      },
+      supported: false
+    }
+  } : SQLITE_CAPABILITIES;
   return {
     ...base,
     maxBindParameters: options.maxBindParameters,
@@ -343,6 +399,10 @@ function buildSqliteCapabilities(options) {
     ...options.vectorStrategy === void 0 ? {} : { vector: buildVectorCapabilities(options.vectorStrategy) }
   };
 }
+function resolveMaxBindParametersCapability(profile, override) {
+  const requested = override ?? profile.maxBindParameters;
+  return profile.hardMaxBindParameters === void 0 ? requested : Math.min(requested, profile.hardMaxBindParameters);
+}
 function createSqliteOperationBackend(options) {
   const {
     capabilities,
@@ -353,7 +413,7 @@ function createSqliteOperationBackend(options) {
     tableNames,
     fulltextStrategy,
     vectorStrategy,
-    vectorSlotLatch
+    contributionMaterializer
   } = options;
   const compiledExecute = executionAdapter.executeCompiled;
   const compiledRun = executionAdapter.executeCompiledRun;
@@ -412,16 +472,10 @@ function createSqliteOperationBackend(options) {
       );
     }
   };
-  async function ensureVectorSlotStorage(slot) {
-    if (vectorStrategy === void 0 || vectorSlotLatch === void 0) return;
-    await vectorSlotLatch.ensure(vectorStrategy, slot, async (statement) => {
-      await execRun(sql.raw(statement));
-    });
-  }
   const vectorEmbeddingMethods = vectorStrategy === void 0 ? {} : {
     async upsertEmbedding(params) {
       const slot = vectorSlotFromParams(params);
-      await ensureVectorSlotStorage(slot);
+      await contributionMaterializer.assertVectorSlot(slot);
       const statements = vectorStrategy.buildUpsert(slot, params, nowIso());
       try {
         for (const statement of statements) {
@@ -434,7 +488,7 @@ function createSqliteOperationBackend(options) {
     async upsertEmbeddingBatch(params) {
       if (params.rows.length === 0) return;
       const slot = vectorSlotFromParams(params);
-      await ensureVectorSlotStorage(slot);
+      await contributionMaterializer.assertVectorSlot(slot);
       const rowsById = new Map(
         params.rows.map((row) => [row.nodeId, row])
       );
@@ -475,7 +529,7 @@ function createSqliteOperationBackend(options) {
     },
     async deleteEmbedding(params) {
       const slot = vectorSlotFromParams(params);
-      await ensureVectorSlotStorage(slot);
+      await contributionMaterializer.assertVectorSlot(slot);
       const statements = vectorStrategy.buildDelete(slot, params);
       for (const statement of statements) {
         await execRun(statement);
@@ -484,7 +538,6 @@ function createSqliteOperationBackend(options) {
     async vectorSearch(params) {
       assertVectorSearchLimit(params.limit);
       const slot = vectorSlotFromParams(params);
-      await ensureVectorSlotStorage(slot);
       const query = vectorStrategy.buildSearch(
         slot,
         params,
@@ -521,7 +574,6 @@ function createSqliteOperationBackend(options) {
           metric: params.vector.metric,
           indexType: params.vector.indexType
         });
-        await ensureVectorSlotStorage(slot);
         const candidates = params.candidates ?? operationStrategy.buildLiveNodeIds(
           params.graphId,
           params.nodeKind
@@ -569,7 +621,7 @@ function createSqliteOperationBackend(options) {
     async createVectorIndex(params) {
       if (vectorStrategy === void 0) return;
       const slot = vectorSlotFromCreateIndexParams(params);
-      await ensureVectorSlotStorage(slot);
+      await contributionMaterializer.ensureVectorSlot(slot);
       const indexStatement = vectorStrategy.buildCreateIndex?.(slot);
       if (indexStatement !== void 0) {
         await execRun(indexStatement);
@@ -664,16 +716,20 @@ function createSqliteBackend(db, options = {}) {
   const executionAdapter = createSqliteExecutionAdapter(db, { profileHints });
   const { isSync, transactionMode } = executionAdapter.profile;
   const vectorStrategy = options.vector;
-  const vectorSlotLatch = vectorStrategy === void 0 ? void 0 : createVectorSlotLatch();
-  const capabilities = {
+  const capabilityOverrides = options.capabilities ?? {};
+  const capabilities = normalizeGraphAnalyticsCapabilities({
     ...buildSqliteCapabilities({
       fulltextStrategy,
       vectorStrategy,
       transactionMode,
       maxBindParameters: executionAdapter.profile.maxBindParameters
     }),
-    ...options.capabilities
-  };
+    ...capabilityOverrides,
+    maxBindParameters: resolveMaxBindParametersCapability(
+      executionAdapter.profile,
+      capabilityOverrides.maxBindParameters
+    )
+  });
   const tableNames = {
     nodes: getTableName(tables2.nodes),
     edges: getTableName(tables2.edges),
@@ -700,6 +756,77 @@ function createSqliteBackend(db, options = {}) {
     fulltextStrategy
   );
   const serializedQueue = transactionMode === "none" ? void 0 : createSerializedExecutionQueue();
+  const matTable = tables2.contributionMaterializations;
+  async function ensureContributionMaterializationsTableImpl() {
+    await db.run(sql.raw(generateSqliteCreateTableSQL(matTable)));
+  }
+  async function getContributionMaterializationRow(identity) {
+    const rows = await db.select().from(matTable).where(
+      and(
+        eq(matTable.graphId, identity.graphId),
+        eq(matTable.logicalName, identity.logicalName),
+        eq(matTable.owner, identity.owner),
+        eq(matTable.tableName, identity.tableName)
+      )
+    );
+    const row = rows[0];
+    if (row === void 0) return void 0;
+    return mapContributionMaterializationRow(
+      row,
+      SQLITE_CONTRIBUTION_MAT_TIMESTAMPS.decode
+    );
+  }
+  async function getContributionMaterializationRows(graphId) {
+    const rows = await db.select().from(matTable).where(eq(matTable.graphId, graphId));
+    return rows.map(
+      (row) => mapContributionMaterializationRow(
+        row,
+        SQLITE_CONTRIBUTION_MAT_TIMESTAMPS.decode
+      )
+    );
+  }
+  async function recordContributionMaterializationRow(params) {
+    await db.insert(matTable).values(
+      buildContributionInsertValues(
+        params,
+        SQLITE_CONTRIBUTION_MAT_TIMESTAMPS.encode
+      )
+    ).onConflictDoUpdate({
+      target: [
+        matTable.graphId,
+        matTable.logicalName,
+        matTable.owner,
+        matTable.tableName
+      ],
+      set: buildContributionOnConflictSet(
+        matTable.materializedAt,
+        params.materializedAt
+      )
+    });
+  }
+  async function deleteContributionMaterializationRow(identity) {
+    await db.delete(matTable).where(
+      and(
+        eq(matTable.graphId, identity.graphId),
+        eq(matTable.logicalName, identity.logicalName),
+        eq(matTable.owner, identity.owner),
+        eq(matTable.tableName, identity.tableName)
+      )
+    );
+  }
+  const contributionMaterializer = createContributionMaterializer({
+    dialect: "sqlite",
+    fulltextStrategy,
+    fulltextTableName: tables2.fulltextTableName,
+    vectorStrategy,
+    execDdl: async (statement) => {
+      await db.run(sql.raw(statement));
+    },
+    ensureMarkerTable: ensureContributionMaterializationsTableImpl,
+    getMarkers: getContributionMaterializationRows,
+    recordMarker: recordContributionMaterializationRow,
+    deleteMarker: deleteContributionMaterializationRow
+  });
   const operations = createSqliteOperationBackend({
     capabilities,
     db,
@@ -708,20 +835,19 @@ function createSqliteBackend(db, options = {}) {
     tableNames,
     fulltextStrategy,
     vectorStrategy,
-    vectorSlotLatch,
+    contributionMaterializer,
     ...serializedQueue === void 0 ? {} : { serializedQueue }
   });
   function runDoSqliteStorageTransaction(run) {
-    const storage = db.$client;
-    const storageTransaction = storage?.transaction;
-    if (typeof storageTransaction !== "function") {
+    const storage = getDurableObjectStorageClient(db);
+    if (storage === void 0) {
       throwSqliteTransactionsDisabled(
-        "transactionMode 'do-sqlite' requires a Drizzle Durable Objects database (drizzle(ctx.storage)) whose `$client` exposes the async storage `transaction(async () => ...)` runner."
+        "transactionMode 'do-sqlite' requires a Drizzle Durable Objects database (drizzle(ctx.storage)) whose `$client` exposes the SQL, transactionSync, and async transaction runners."
       );
     }
     return runWithSerializedQueue(
       serializedQueue,
-      async () => storageTransaction.call(storage, run)
+      () => storage.transaction(run)
     );
   }
   async function runFrameStatement(query) {
@@ -748,7 +874,9 @@ function createSqliteBackend(db, options = {}) {
           profileHints: { isSync },
           tableNames,
           fulltextStrategy,
-          vectorStrategy});
+          vectorStrategy,
+          contributionMaterializer
+        });
         await runFrameStatement(sql`BEGIN IMMEDIATE`);
         try {
           const result = await fn(txBackend);
@@ -769,7 +897,9 @@ function createSqliteBackend(db, options = {}) {
           profileHints: { isSync },
           tableNames,
           fulltextStrategy,
-          vectorStrategy});
+          vectorStrategy,
+          contributionMaterializer
+        });
         return fn(txBackend);
       });
     }
@@ -784,63 +914,15 @@ function createSqliteBackend(db, options = {}) {
             profileHints: { isSync },
             tableNames,
             fulltextStrategy,
-            vectorStrategy});
+            vectorStrategy,
+            contributionMaterializer
+          });
           return fn(txBackend);
         },
         { behavior: "immediate" }
       )
     );
   }
-  const matTable = tables2.contributionMaterializations;
-  async function ensureContributionMaterializationsTableImpl() {
-    await db.run(sql.raw(generateSqliteCreateTableSQL(matTable)));
-  }
-  async function getContributionMaterializationRow(identity) {
-    const rows = await db.select().from(matTable).where(
-      and(
-        eq(matTable.graphId, identity.graphId),
-        eq(matTable.logicalName, identity.logicalName),
-        eq(matTable.owner, identity.owner),
-        eq(matTable.tableName, identity.tableName)
-      )
-    );
-    const row = rows[0];
-    if (row === void 0) return void 0;
-    return mapContributionMaterializationRow(
-      row,
-      SQLITE_CONTRIBUTION_MAT_TIMESTAMPS.decode
-    );
-  }
-  async function recordContributionMaterializationRow(params) {
-    await db.insert(matTable).values(
-      buildContributionInsertValues(
-        params,
-        SQLITE_CONTRIBUTION_MAT_TIMESTAMPS.encode
-      )
-    ).onConflictDoUpdate({
-      target: [
-        matTable.graphId,
-        matTable.logicalName,
-        matTable.owner,
-        matTable.tableName
-      ],
-      set: buildContributionOnConflictSet(
-        matTable.materializedAt,
-        params.materializedAt
-      )
-    });
-  }
-  const contributionMaterializer = createContributionMaterializer({
-    dialect: "sqlite",
-    fulltextStrategy,
-    fulltextTableName: tables2.fulltextTableName,
-    execDdl: async (statement) => {
-      await db.run(sql.raw(statement));
-    },
-    ensureMarkerTable: ensureContributionMaterializationsTableImpl,
-    getMarker: getContributionMaterializationRow,
-    recordMarker: recordContributionMaterializationRow
-  });
   function bindTransactionBackend(tx) {
     const txBackend = createTransactionBackend({
       capabilities,
@@ -849,11 +931,30 @@ function createSqliteBackend(db, options = {}) {
       profileHints: { isSync },
       tableNames,
       fulltextStrategy,
-      vectorStrategy});
+      vectorStrategy,
+      contributionMaterializer
+    });
     return gateFulltext(txBackend, contributionMaterializer.assertInitialized);
   }
   const backend = {
     ...operations,
+    ...isSync && transactionMode === "sql" && executionAdapter.executePreparedRunBatch !== void 0 ? {
+      async trustedImport(fn) {
+        return backend.transaction(async (tx) => {
+          await assertTrustedImportDatabaseEmpty(tx, tableNames);
+          const indexDefinitions = await suspendSqliteSecondaryIndexes(
+            tx,
+            tableNames
+          );
+          const result = await fn(
+            createSqliteTrustedImportSession(executionAdapter, tableNames)
+          );
+          await restoreSecondaryIndexes(tx, indexDefinitions);
+          await analyzeImportedTables(tx, tableNames);
+          return result;
+        });
+      }
+    } : {},
     async bootstrapTables() {
       const statements = generateSqliteDDL(tables2, fulltextStrategy);
       for (const statement of statements) {
@@ -906,10 +1007,7 @@ function createSqliteBackend(db, options = {}) {
         )
       ).onConflictDoUpdate({
         target: t.indexName,
-        set: buildMaterializationOnConflictSet(
-          t.materializedAt,
-          params.materializedAt
-        )
+        set: buildMaterializationOnConflictSet(params.materializedAt)
       });
     },
     async ensureContributionMaterializationsTable() {
@@ -969,6 +1067,27 @@ function createSqliteBackend(db, options = {}) {
     async ensureFulltextTable(graphId) {
       await contributionMaterializer.ensureRuntimeContributions(graphId);
     },
+    // Vector counterparts of the runtime-contribution methods. Present
+    // only when a vector strategy is wired (omitted on a plain SQLite
+    // connection with no vector extension), mirroring the embedding/
+    // search methods.
+    ...vectorStrategy === void 0 ? {} : {
+      async ensureVectorSlotContribution(slot, options_) {
+        await contributionMaterializer.ensureVectorSlot(slot, options_);
+      },
+      async ensureVectorSlotContributions(slots, options_) {
+        await contributionMaterializer.ensureVectorSlots(slots, options_);
+      },
+      async assertVectorSlotInitialized(slot) {
+        await contributionMaterializer.assertVectorSlot(slot);
+      },
+      async assertVectorSlotsInitialized(slots) {
+        await contributionMaterializer.assertVectorSlots(slots);
+      },
+      async deleteVectorSlotContribution(slot) {
+        await contributionMaterializer.dropVectorSlot(slot);
+      }
+    },
     async getReconciliationMarker(graphId) {
       const t = tables2.reconciliationMarkers;
       const rows = await db.select().from(t).where(eq(t.graphId, graphId));
@@ -1006,7 +1125,14 @@ function createSqliteBackend(db, options = {}) {
         (target) => target.setActiveVersion(params)
       );
     },
-    async transaction(fn, _options) {
+    async transaction(fn, options2) {
+      const temporaryWrites = options2?.temporaryWrites === INTERNAL_TEMPORARY_WRITES;
+      if (temporaryWrites && options2.accessMode !== "read_only") {
+        throw new ConfigurationError(
+          "Temporary-write transactions must be semantically read-only.",
+          { dialect: "sqlite" }
+        );
+      }
       if (transactionMode === "none") {
         throwSqliteTransactionsDisabled(
           "This SQLite backend does not support atomic transactions. Operations within a transaction are not rolled back on failure. Use backend.capabilities.transactions to check for transaction support, or use individual operations with manual error handling."
@@ -1022,8 +1148,12 @@ function createSqliteBackend(db, options = {}) {
             profileHints: { isSync },
             tableNames,
             fulltextStrategy,
-            vectorStrategy});
-          await runFrameStatement(sql`BEGIN IMMEDIATE`);
+            vectorStrategy,
+            contributionMaterializer
+          });
+          await runFrameStatement(
+            options2?.accessMode === "read_only" || temporaryWrites ? sql`BEGIN` : sql`BEGIN IMMEDIATE`
+          );
           try {
             const result = await fn(
               gateFulltext(
@@ -1048,7 +1178,7 @@ function createSqliteBackend(db, options = {}) {
       return runWithSerializedQueue(
         serializedQueue,
         async () => db.transaction(async (tx) => fn(bindTransactionBackend(tx), tx), {
-          behavior: "immediate"
+          behavior: options2?.accessMode === "read_only" || temporaryWrites ? "deferred" : "immediate"
         })
       );
     },
@@ -1084,10 +1214,10 @@ function createTransactionBackend(options) {
     tableNames: options.tableNames,
     fulltextStrategy: options.fulltextStrategy,
     vectorStrategy: options.vectorStrategy,
-    ...options.vectorStrategy === void 0 ? {} : { vectorSlotLatch: createVectorSlotLatch() }
+    contributionMaterializer: options.contributionMaterializer
   });
 }
 
 export { createSqliteBackend };
-//# sourceMappingURL=chunk-BJVEU3ZL.js.map
-//# sourceMappingURL=chunk-BJVEU3ZL.js.map
+//# sourceMappingURL=chunk-J4IUSYFF.js.map
+//# sourceMappingURL=chunk-J4IUSYFF.js.map