@nicia-ai/typegraph 0.33.0 → 0.35.0

package/dist/{chunk-JHOBXD7O.js → chunk-3TWF3SH4.js}

@@ -1,9 +1,10 @@
-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, gateFulltext, compileQueryWithDialect, vectorSlotFromDropIndexParams, vectorSlotFromCreateIndexParams, vectorSlotFromParams, mapVectorWriteError, getOrCreateLru } from './chunk-UPDMJEW6.js';
-import { tables } from './chunk-DJYRRDHA.js';
-import { createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, SQLITE_CAPABILITIES, nowIso, SQLITE_MAX_BIND_PARAMETERS, coerceNumericScore } from './chunk-PYD3UCDU.js';
-import { isMissingTableError } from './chunk-GYVBEZAO.js';
-import { fts5Strategy, buildVectorCapabilities, buildFulltextCapabilities, assertVectorSearchLimit } from './chunk-C4C4Q7A6.js';
-import { ConfigurationError, BackendDisposedError } from './chunk-TQOYM4LN.js';
+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-WDBCBWC4.js';
+import { tables } from './chunk-VHMPG6UL.js';
+import { createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, quoteIdentifier, nowIso, coerceNumericScore } from './chunk-55MZDDZV.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-JBTOYDMN.js';
+import { isMissingTableError } from './chunk-I7ZUZKFD.js';
+import { ConfigurationError, BackendDisposedError } from './chunk-MP2JQKSG.js';
 import { getTableName, sql, and, eq, isNull, inArray } from 'drizzle-orm';
 import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
 
@@ -61,6 +62,44 @@ function detectTransactionMode(db, profileHints, isSync) {
   if (isSync) return "sql";
   return "drizzle";
 }
+var MAX_VARIABLE_NUMBER_COMPILE_OPTION = /^MAX_VARIABLE_NUMBER=(\d+)$/;
+var FIRST_MODERN_BIND_LIMIT_MAJOR = 3;
+var FIRST_MODERN_BIND_LIMIT_MINOR = 32;
+function parseCompiledMaxVariableNumber(rows) {
+  for (const row of rows) {
+    if (typeof row !== "object" || row === null) continue;
+    const option = row.compile_options;
+    if (typeof option !== "string") continue;
+    const match = MAX_VARIABLE_NUMBER_COMPILE_OPTION.exec(option);
+    if (match !== null) return Number(match[1]);
+  }
+  return void 0;
+}
+function hasModernBindLimitByVersion(rows) {
+  const first = rows[0];
+  if (typeof first !== "object" || first === null) return false;
+  const version = first.version;
+  if (typeof version !== "string") return false;
+  const [major = 0, minor = 0] = version.split(".").map(Number);
+  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;
+  if (sqliteClient === void 0) return SQLITE_MAX_BIND_PARAMETERS;
+  try {
+    const compiled = parseCompiledMaxVariableNumber(
+      sqliteClient.prepare("PRAGMA compile_options").all()
+    );
+    if (compiled !== void 0) return compiled;
+    const isModern = hasModernBindLimitByVersion(
+      sqliteClient.prepare("SELECT sqlite_version() AS version").all()
+    );
+    return isModern ? MODERN_SQLITE_MAX_BIND_PARAMETERS : SQLITE_MAX_BIND_PARAMETERS;
+  } catch {
+    return SQLITE_MAX_BIND_PARAMETERS;
+  }
+}
 function resolveSqliteClient(db) {
   const databaseWithClient = db;
   const sqliteClient = databaseWithClient.$client;
@@ -103,6 +142,7 @@ function createSqliteExecutionAdapter(db, statementCacheMaxOrOptions = {}) {
   const transactionMode = detectTransactionMode(db, profileHints, isSync);
   const profile = {
     isSync,
+    maxBindParameters: detectMaxBindParameters(db, sqliteClient),
     supportsCompiledExecution: sqliteClient !== void 0,
     transactionMode
   };
@@ -117,6 +157,19 @@ function createSqliteExecutionAdapter(db, statementCacheMaxOrOptions = {}) {
       );
       const rows = preparedStatement.all(...compiledQuery.params);
       return Promise.resolve(rows);
+    }, executeCompiledRun2 = function(compiledQuery) {
+      const preparedStatement = getOrCreatePreparedStatement(
+        statementCache,
+        client,
+        compiledQuery.sql,
+        statementCacheMax
+      );
+      if (preparedStatement.run === void 0 || preparedStatement.reader === true) {
+        preparedStatement.all(...compiledQuery.params);
+      } else {
+        preparedStatement.run(...compiledQuery.params);
+      }
+      return Promise.resolve();
     };
     const client = sqliteClient;
     const statementCache = /* @__PURE__ */ new Map();
@@ -130,6 +183,7 @@ function createSqliteExecutionAdapter(db, statementCacheMaxOrOptions = {}) {
         return executeCompiled2(compiledQuery);
       },
       executeCompiled: executeCompiled2,
+      executeCompiledRun: executeCompiledRun2,
       prepare(sqlText) {
         return createPreparedStatementExecutor(
           client,
@@ -155,27 +209,53 @@ function createSqliteExecutionAdapter(db, statementCacheMaxOrOptions = {}) {
 // src/backend/drizzle/sqlite.ts
 var NODE_INSERT_PARAM_COUNT = 9;
 var EDGE_INSERT_PARAM_COUNT = 12;
-var SQLITE_NODE_INSERT_BATCH_SIZE = Math.max(
-  1,
-  Math.floor(SQLITE_MAX_BIND_PARAMETERS / NODE_INSERT_PARAM_COUNT)
-);
-var SQLITE_EDGE_INSERT_BATCH_SIZE = Math.max(
-  1,
-  Math.floor(SQLITE_MAX_BIND_PARAMETERS / EDGE_INSERT_PARAM_COUNT)
-);
-var SQLITE_GET_NODES_ID_CHUNK_SIZE = Math.max(
-  1,
-  SQLITE_MAX_BIND_PARAMETERS - 2
-);
-var SQLITE_GET_EDGES_ID_CHUNK_SIZE = Math.max(
-  1,
-  SQLITE_MAX_BIND_PARAMETERS - 1
-);
+var GET_NODES_FIXED_PARAM_COUNT = 2;
+var GET_EDGES_FIXED_PARAM_COUNT = 1;
 var CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT = 3;
-var SQLITE_CHECK_UNIQUE_BATCH_CHUNK_SIZE = Math.max(
-  1,
-  SQLITE_MAX_BIND_PARAMETERS - CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT
-);
+var FULLTEXT_UPSERT_PARAM_COUNT = 6;
+var FULLTEXT_DELETE_FIXED_PARAM_COUNT = 2;
+var UNIQUE_INSERT_PARAM_COUNT = 6;
+var SQLITE_ANALYZE_ROW_LIMIT = 1e3;
+function computeSqliteBatchChunkSizes(maxBindParameters) {
+  return {
+    checkUniqueBatchChunkSize: Math.max(
+      1,
+      maxBindParameters - CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT
+    ),
+    embeddingUpsertBatchSize: Math.max(
+      1,
+      Math.floor(maxBindParameters / EMBEDDING_UPSERT_PARAM_COUNT)
+    ),
+    fulltextUpsertBatchSize: Math.max(
+      1,
+      Math.floor(maxBindParameters / FULLTEXT_UPSERT_PARAM_COUNT)
+    ),
+    fulltextDeleteChunkSize: Math.max(
+      1,
+      maxBindParameters - FULLTEXT_DELETE_FIXED_PARAM_COUNT
+    ),
+    edgeInsertBatchSize: Math.max(
+      1,
+      Math.floor(maxBindParameters / EDGE_INSERT_PARAM_COUNT)
+    ),
+    getEdgesChunkSize: Math.max(
+      1,
+      maxBindParameters - GET_EDGES_FIXED_PARAM_COUNT
+    ),
+    getNodesChunkSize: Math.max(
+      1,
+      maxBindParameters - GET_NODES_FIXED_PARAM_COUNT
+    ),
+    nodeInsertBatchSize: Math.max(
+      1,
+      Math.floor(maxBindParameters / NODE_INSERT_PARAM_COUNT)
+    ),
+    uniqueInsertBatchSize: Math.max(
+      1,
+      Math.floor(maxBindParameters / UNIQUE_INSERT_PARAM_COUNT)
+    )
+  };
+}
 var toNodeRow = createNodeRowMapper(SQLITE_ROW_MAPPER_CONFIG);
 var toEdgeRow = createEdgeRowMapper(SQLITE_ROW_MAPPER_CONFIG);
 var toUniqueRow = createUniqueRowMapper(SQLITE_ROW_MAPPER_CONFIG);
@@ -188,9 +268,30 @@ function pendingForever() {
 }
 function noop() {
 }
+var queueTaskContext;
+async function loadQueueTaskContext() {
+  try {
+    const asyncHooks = await import('async_hooks');
+    queueTaskContext = new asyncHooks.AsyncLocalStorage();
+  } catch {
+  }
+}
+void loadQueueTaskContext();
+function rejectReentrantQueueSubmission() {
+  return Promise.reject(
+    new ConfigurationError(
+      "This operation was awaited from inside a transaction running on the same SQLite backend and would deadlock: the transaction holds the backend's serialized execution slot until it completes, so the operation could never run.",
+      { backend: "sqlite", capability: "concurrentRootAccess" },
+      {
+        suggestion: "Inside a store.transaction callback, use the transaction-scoped context (tx.nodes / tx.edges / tx.backend) instead of the root store or backend, or move the operation outside the transaction."
+      }
+    )
+  );
+}
 function createSerializedExecutionQueue() {
   let tail = Promise.resolve();
   let disposed = false;
+  const taskMarker = {};
   function isDisposed() {
     return disposed;
   }
@@ -200,10 +301,14 @@ function createSerializedExecutionQueue() {
     },
     runExclusive(task) {
       if (isDisposed()) return Promise.reject(new BackendDisposedError());
+      if (queueTaskContext?.getStore() === taskMarker) {
+        return rejectReentrantQueueSubmission();
+      }
       const runTask = async () => {
         if (isDisposed()) return pendingForever();
         try {
-          return await task();
+          const context = queueTaskContext;
+          return context === void 0 ? await task() : await context.run(taskMarker, () => task());
         } catch (error) {
           if (isDisposed()) return pendingForever();
           throw error;
@@ -233,6 +338,7 @@ function buildSqliteCapabilities(options) {
   const base = options.transactionMode === "none" ? { ...SQLITE_CAPABILITIES, transactions: false } : SQLITE_CAPABILITIES;
   return {
     ...base,
+    maxBindParameters: options.maxBindParameters,
     fulltext: buildFulltextCapabilities(options.fulltextStrategy),
     ...options.vectorStrategy === void 0 ? {} : { vector: buildVectorCapabilities(options.vectorStrategy) }
   };
@@ -249,30 +355,40 @@ function createSqliteOperationBackend(options) {
     vectorStrategy,
     vectorSlotLatch
   } = options;
+  const compiledExecute = executionAdapter.executeCompiled;
+  const compiledRun = executionAdapter.executeCompiledRun;
   function execGet(query) {
     return runWithSerializedQueue(serializedQueue, async () => {
-      const rows = await db.all(query);
+      if (compiledExecute === void 0) {
+        const rows2 = await db.all(query);
+        return rows2[0];
+      }
+      const rows = await compiledExecute(executionAdapter.compile(query));
       return rows[0];
     });
   }
   function execAll(query) {
     return runWithSerializedQueue(serializedQueue, async () => {
-      return await db.all(query);
+      if (compiledExecute === void 0) {
+        return await db.all(query);
+      }
+      return [...await compiledExecute(executionAdapter.compile(query))];
     });
   }
   function execRun(query) {
     return runWithSerializedQueue(serializedQueue, async () => {
-      await db.run(query);
+      if (compiledRun === void 0) {
+        await db.run(query);
+        return;
+      }
+      await compiledRun(executionAdapter.compile(query));
     });
   }
+  const batchConfig = computeSqliteBatchChunkSizes(
+    capabilities.maxBindParameters ?? SQLITE_MAX_BIND_PARAMETERS
+  );
   const commonBackend = createCommonOperationBackend({
-    batchConfig: {
-      checkUniqueBatchChunkSize: SQLITE_CHECK_UNIQUE_BATCH_CHUNK_SIZE,
-      edgeInsertBatchSize: SQLITE_EDGE_INSERT_BATCH_SIZE,
-      getEdgesChunkSize: SQLITE_GET_EDGES_ID_CHUNK_SIZE,
-      getNodesChunkSize: SQLITE_GET_NODES_ID_CHUNK_SIZE,
-      nodeInsertBatchSize: SQLITE_NODE_INSERT_BATCH_SIZE
-    },
+    batchConfig,
     execution: {
       execAll,
       execGet,
@@ -315,6 +431,48 @@ function createSqliteOperationBackend(options) {
         throw mapVectorWriteError(error, params);
       }
     },
+    async upsertEmbeddingBatch(params) {
+      if (params.rows.length === 0) return;
+      const slot = vectorSlotFromParams(params);
+      await ensureVectorSlotStorage(slot);
+      const rowsById = new Map(
+        params.rows.map((row) => [row.nodeId, row])
+      );
+      const rows = [...rowsById.values()];
+      const timestamp = nowIso();
+      try {
+        for (const chunk2 of chunk(
+          rows,
+          batchConfig.embeddingUpsertBatchSize
+        )) {
+          const statements = vectorStrategy.buildUpsertBatch === void 0 ? chunk2.flatMap(
+            (row) => vectorStrategy.buildUpsert(
+              slot,
+              {
+                graphId: params.graphId,
+                nodeKind: params.nodeKind,
+                nodeId: row.nodeId,
+                fieldPath: params.fieldPath,
+                embedding: row.embedding,
+                dimensions: params.dimensions,
+                metric: params.metric,
+                indexType: params.indexType
+              },
+              timestamp
+            )
+          ) : vectorStrategy.buildUpsertBatch(
+            slot,
+            { ...params, rows: chunk2 },
+            timestamp
+          );
+          for (const statement of statements) {
+            await execRun(statement);
+          }
+        }
+      } catch (error) {
+        throw mapVectorWriteError(error, params);
+      }
+    },
     async deleteEmbedding(params) {
       const slot = vectorSlotFromParams(params);
       await ensureVectorSlotStorage(slot);
@@ -327,7 +485,16 @@ function createSqliteOperationBackend(options) {
       assertVectorSearchLimit(params.limit);
       const slot = vectorSlotFromParams(params);
       await ensureVectorSlotStorage(slot);
-      const query = vectorStrategy.buildSearch(slot, params);
+      const query = vectorStrategy.buildSearch(
+        slot,
+        params,
+        // Store-compiled candidates (predicates + subclass + currency)
+        // take precedence; the live-node default covers direct backend use.
+        params.candidates ?? operationStrategy.buildLiveNodeIds(
+          params.graphId,
+          params.nodeKind
+        )
+      );
       let rows;
       try {
         rows = await execAll(query);
@@ -338,7 +505,57 @@ function createSqliteOperationBackend(options) {
         nodeId: row.node_id,
         score: row.score
       }));
-    }
+    },
+    // Single-statement hybrid needs ROW_NUMBER(); a capability profile
+    // that disables window functions keeps the store's multi-statement
+    // fallback by simply not exposing the member.
+    ...capabilities.windowFunctions ? {
+      async hybridSearch(params) {
+        assertVectorSearchLimit(params.limit);
+        assertVectorSearchLimit(params.vector.k);
+        const slot = vectorSlotFromParams({
+          graphId: params.graphId,
+          nodeKind: params.nodeKind,
+          fieldPath: params.vector.fieldPath,
+          dimensions: params.vector.dimensions,
+          metric: params.vector.metric,
+          indexType: params.vector.indexType
+        });
+        await ensureVectorSlotStorage(slot);
+        const candidates = params.candidates ?? operationStrategy.buildLiveNodeIds(
+          params.graphId,
+          params.nodeKind
+        );
+        const vectorParams = {
+          graphId: params.graphId,
+          nodeKind: params.nodeKind,
+          fieldPath: params.vector.fieldPath,
+          queryEmbedding: params.vector.queryEmbedding,
+          metric: params.vector.metric,
+          dimensions: params.vector.dimensions,
+          indexType: params.vector.indexType,
+          limit: params.vector.k,
+          ...params.vector.minScore === void 0 ? {} : { minScore: params.vector.minScore }
+        };
+        const vectorSql = vectorStrategy.buildSearch(
+          slot,
+          vectorParams,
+          hybridCandidatesRef()
+        );
+        const statement = operationStrategy.buildHybridSearch(
+          { ...params, candidates },
+          vectorSql,
+          params.vector.metric === "cosine"
+        );
+        let raw;
+        try {
+          raw = await execAll(statement);
+        } catch (error) {
+          throw mapVectorWriteError(error, vectorParams);
+        }
+        return raw.map((row) => mapHybridSearchRow(row, toNodeRow));
+      }
+    } : {}
   };
   const operationBackend = {
     ...commonBackend,
@@ -389,19 +606,32 @@ function createSqliteOperationBackend(options) {
     async upsertFulltextBatch(params) {
       if (params.rows.length === 0) return;
       const timestamp = nowIso();
-      const statements = operationStrategy.buildUpsertFulltextBatch(
-        params,
-        timestamp
-      );
-      for (const stmt of statements) {
-        await execRun(stmt);
+      for (const rows of chunk(
+        params.rows,
+        batchConfig.fulltextUpsertBatchSize
+      )) {
+        const statements = operationStrategy.buildUpsertFulltextBatch(
+          { ...params, rows },
+          timestamp
+        );
+        for (const stmt of statements) {
+          await execRun(stmt);
+        }
       }
     },
     async deleteFulltextBatch(params) {
       if (params.nodeIds.length === 0) return;
-      const statements = operationStrategy.buildDeleteFulltextBatch(params);
-      for (const stmt of statements) {
-        await execRun(stmt);
+      for (const nodeIds of chunk(
+        params.nodeIds,
+        batchConfig.fulltextDeleteChunkSize
+      )) {
+        const statements = operationStrategy.buildDeleteFulltextBatch({
+          ...params,
+          nodeIds
+        });
+        for (const stmt of statements) {
+          await execRun(stmt);
+        }
       }
     },
     async fulltextSearch(params) {
@@ -439,7 +669,8 @@ function createSqliteBackend(db, options = {}) {
     ...buildSqliteCapabilities({
       fulltextStrategy,
       vectorStrategy,
-      transactionMode
+      transactionMode,
+      maxBindParameters: executionAdapter.profile.maxBindParameters
     }),
     ...options.capabilities
   };
@@ -449,14 +680,26 @@ function createSqliteBackend(db, options = {}) {
     recordedNodes: getTableName(tables2.recordedNodes),
     recordedEdges: getTableName(tables2.recordedEdges),
     recordedClock: getTableName(tables2.recordedClock),
+    revisionOrigins: getTableName(tables2.revisionOrigins),
     fulltext: tables2.fulltextTableName,
     uniques: getTableName(tables2.uniques)
   };
+  const coreAnalyzeTables = [
+    tableNames.nodes,
+    tableNames.edges,
+    tableNames.uniques,
+    tableNames.fulltext
+  ];
+  const recordedAnalyzeTables = [
+    tableNames.recordedNodes,
+    tableNames.recordedEdges,
+    tableNames.recordedClock
+  ];
   const operationStrategy = createSqliteOperationStrategy(
     tables2,
     fulltextStrategy
   );
-  const serializedQueue = isSync ? createSerializedExecutionQueue() : void 0;
+  const serializedQueue = transactionMode === "none" ? void 0 : createSerializedExecutionQueue();
   const operations = createSqliteOperationBackend({
     capabilities,
     db,
@@ -481,6 +724,14 @@ function createSqliteBackend(db, options = {}) {
       async () => storageTransaction.call(storage, run)
     );
   }
+  async function runFrameStatement(query) {
+    const compiledRun = executionAdapter.executeCompiledRun;
+    if (compiledRun === void 0) {
+      await db.run(query);
+      return;
+    }
+    await compiledRun(executionAdapter.compile(query));
+  }
   function runSchemaWriteTransaction(fn) {
     if (transactionMode === "none") {
       throwSqliteTransactionsDisabled(
@@ -494,17 +745,17 @@ function createSqliteBackend(db, options = {}) {
           db,
           executionAdapter,
           operationStrategy,
-          profileHints: { isSync: true },
+          profileHints: { isSync },
           tableNames,
           fulltextStrategy,
           vectorStrategy});
-        db.run(sql`BEGIN IMMEDIATE`);
+        await runFrameStatement(sql`BEGIN IMMEDIATE`);
         try {
           const result = await fn(txBackend);
-          db.run(sql`COMMIT`);
+          await runFrameStatement(sql`COMMIT`);
           return result;
         } catch (error) {
-          db.run(sql`ROLLBACK`);
+          await runFrameStatement(sql`ROLLBACK`);
           throw error;
         }
       });
@@ -609,6 +860,11 @@ function createSqliteBackend(db, options = {}) {
         await db.run(sql.raw(statement));
       }
     },
+    async ensureRevisionOriginsTable() {
+      await db.run(
+        sql.raw(generateSqliteCreateTableSQL(tables2.revisionOrigins))
+      );
+    },
     // Every fulltext-touching method asserts the durable marker instead
     // of lazily emitting DDL. Steady state performs zero ensure; an
     // uninitialized database throws `StoreNotInitializedError` rather
@@ -726,7 +982,19 @@ function createSqliteBackend(db, options = {}) {
       });
     },
     async refreshStatistics() {
-      await db.run(sql`ANALYZE`);
+      await db.run(
+        sql`PRAGMA analysis_limit = ${sql.raw(String(SQLITE_ANALYZE_ROW_LIMIT))}`
+      );
+      for (const tableName of coreAnalyzeTables) {
+        await db.run(sql`ANALYZE ${quoteIdentifier(tableName)}`);
+      }
+      for (const tableName of recordedAnalyzeTables) {
+        try {
+          await db.run(sql`ANALYZE ${quoteIdentifier(tableName)}`);
+        } catch (error) {
+          if (!isMissingTableError(error)) throw error;
+        }
+      }
     },
     async commitSchemaVersion(params) {
       return runSchemaWriteTransaction(
@@ -751,11 +1019,11 @@ function createSqliteBackend(db, options = {}) {
             db,
             executionAdapter,
             operationStrategy,
-            profileHints: { isSync: true },
+            profileHints: { isSync },
             tableNames,
             fulltextStrategy,
             vectorStrategy});
-          db.run(sql`BEGIN`);
+          await runFrameStatement(sql`BEGIN IMMEDIATE`);
           try {
             const result = await fn(
               gateFulltext(
@@ -764,10 +1032,10 @@ function createSqliteBackend(db, options = {}) {
               ),
               db
             );
-            db.run(sql`COMMIT`);
+            await runFrameStatement(sql`COMMIT`);
             return result;
           } catch (error) {
-            db.run(sql`ROLLBACK`);
+            await runFrameStatement(sql`ROLLBACK`);
             throw error;
           }
         });
@@ -779,9 +1047,9 @@ function createSqliteBackend(db, options = {}) {
       }
       return runWithSerializedQueue(
         serializedQueue,
-        async () => db.transaction(
-          async (tx) => fn(bindTransactionBackend(tx), tx)
-        )
+        async () => db.transaction(async (tx) => fn(bindTransactionBackend(tx), tx), {
+          behavior: "immediate"
+        })
       );
     },
     adoptTransaction(externalTx) {
@@ -821,5 +1089,5 @@ function createTransactionBackend(options) {
 }
 
 export { createSqliteBackend };
-//# sourceMappingURL=chunk-JHOBXD7O.js.map
-//# sourceMappingURL=chunk-JHOBXD7O.js.map
+//# sourceMappingURL=chunk-3TWF3SH4.js.map
+//# sourceMappingURL=chunk-3TWF3SH4.js.map