@cortexkit/pi-magic-context 0.49.19 → 0.49.21

package/dist/auto-search-worker.js

@@ -1,3 +1,7 @@
+import {
+  exitOnWorkerClose
+} from "./index-54wmg4rj.js";
+
 // ../plugin/src/hooks/magic-context/auto-search-worker.ts
 import { parentPort, workerData } from "node:worker_threads";
 if (!parentPort)
@@ -14,20 +18,22 @@ var [
   { getMemoriesByProject },
   { installProjectEmbeddingSearchBridge },
   { searchMessageHistory, unifiedSearch },
+  { getLastCompartmentChunkPoolWarm, maintainCompartmentChunkSearchPools },
   { setEmbeddingSessionBusy },
   { getHarness, setHarness },
   { Database, registerSqliteDiagnosticSink },
   { log }
 ] = await Promise.all([
-  import("./embedding-backfill-vwag34t0.js"),
+  import("./embedding-backfill-2vh6m3bg.js"),
   import("./embedding-cache-7rp4gqzr.js"),
-  import("./storage-memory-yxxc5v4n.js"),
-  import("./project-embedding-registry-vf1ncptn.js"),
-  import("./search-wh7b9zht.js"),
+  import("./storage-memory-0ndn65fm.js"),
+  import("./project-embedding-registry-hfyzs654.js"),
+  import("./search-jhfh3tsj.js"),
+  import("./compartment-chunk-embedding-y01m95c2.js"),
   import("./embedding-activity-ew6dshfd.js"),
   import("./harness-9872e0ym.js"),
-  import("./sqlite-fsp0sf3r.js"),
-  import("./logger-dygt96rn.js")
+  import("./sqlite-v89bj0yy.js"),
+  import("./logger-shetp43v.js")
 ]);
 setHarness(input.harness);
 registerSqliteDiagnosticSink(log, getHarness);
@@ -53,6 +59,27 @@ function request(message) {
 }
 db = new Database(input.path, input.job === "backfill" ? undefined : { readonly: true });
 db.exec("PRAGMA busy_timeout = 250");
+var { closePort } = exitOnWorkerClose(port, () => db.close());
+var CHUNK_POOL_MAINTENANCE_INTERVAL_MS = 5000;
+var maintenanceTimer;
+var maintaining = false;
+function maintainChunkPools() {
+  if (maintaining)
+    return;
+  maintaining = true;
+  maintainCompartmentChunkSearchPools(db).catch(() => {}).finally(() => {
+    maintaining = false;
+  });
+}
+function scheduleChunkPoolMaintenance() {
+  if (!persistent)
+    return;
+  if (!maintenanceTimer) {
+    maintenanceTimer = setInterval(maintainChunkPools, CHUNK_POOL_MAINTENANCE_INTERVAL_MS);
+    maintenanceTimer.unref?.();
+  }
+  setTimeout(maintainChunkPools, 0);
+}
 async function run(jobInput) {
   input = jobInput;
   queryDimensions = null;
@@ -98,15 +125,27 @@ async function run(jobInput) {
       const outcome = searchMessageHistory(db, input.messageRequest);
       port.postMessage({ kind: "messages", outcome });
     } else {
+      const jobStarted = performance.now();
+      const steps = {};
       const results = await unifiedSearch(db, input.sessionId, input.projectPath, input.query, {
         ...input.options,
         backfillMemoryEmbeddings: false,
         countRetrievals: false,
         measurementDisabled: true,
         embedQuery: async (text) => (await request({ kind: "query", text })).result ?? null,
-        isEmbeddingRuntimeEnabled: () => input.embeddingRuntimeEnabled
+        isEmbeddingRuntimeEnabled: () => input.embeddingRuntimeEnabled,
+        stepTimings: steps
+      });
+      port.postMessage({
+        kind: "result",
+        results,
+        timings: {
+          steps,
+          jobMs: performance.now() - jobStarted,
+          lastPoolWarm: getLastCompartmentChunkPoolWarm()
+        }
       });
-      port.postMessage({ kind: "result", results });
+      scheduleChunkPoolMaintenance();
     }
   } catch (error) {
     port.postMessage({
@@ -117,7 +156,7 @@ async function run(jobInput) {
     setEmbeddingSessionBusy(input.sessionId, false);
     if (!persistent) {
       db.close();
-      port?.close();
+      closePort();
     }
   }
 }

package/dist/chunk-embedding-write-worker.js

@@ -3,39 +3,43 @@ import {
 } from "./index-0h2mkab2.js";
 import {
   Database2
-} from "./index-rrwv9y2k.js";
+} from "./index-2qtx0q6h.js";
 import {
   configureContextDatabasePragmas2
 } from "./index-fapenpch.js";
-import"./index-1kcfwk9c.js";
-import"./index-7bqrfyny.js";
-import"./index-d8gc0112.js";
+import {
+  isWorkerCloseMessage,
+  exitOnWorkerClose
+} from "./index-54wmg4rj.js";
+import"./index-my0dn413.js";
+import"./index-fgs78jyd.js";
+import"./index-gwxaz0z5.js";
 import"./index-399p688g.js";
-import"./index-vktahpdj.js";
-import"./index-yygsh681.js";
+import"./index-at6py2k3.js";
+import"./index-579m1751.js";
 import {
-  replaceCompartmentChunkEmbeddings,
-  recordChunkEmbedBackoff,
-  loadUnembeddedSessionChunkCandidates,
-  countUnembeddedSessionCompartments
-} from "./index-xnch62s6.js";
+  replaceCompartmentChunkEmbeddings2,
+  recordChunkEmbedBackoff2,
+  loadUnembeddedSessionChunkCandidates2,
+  countUnembeddedSessionCompartments2
+} from "./index-vx6f7wff.js";
 import {
   recordSessionProjectIdentity,
   acquireGitSweepLease,
   renewGitSweepLease,
   releaseGitSweepLease
-} from "./index-svgkv4g2.js";
-import"./index-g7p75667.js";
-import"./index-apgwdby5.js";
+} from "./index-j3pz3a1b.js";
+import"./index-hxp6q5f8.js";
+import"./index-n4wyxcgr.js";
 import {
   LATEST_SUPPORTED_VERSION,
   enforceSchemaFence
-} from "./index-sqt2haap.js";
-import"./index-msqrs4nf.js";
-import"./index-jrap43gc.js";
+} from "./index-dbgg6hsf.js";
+import"./index-3c3ztwgc.js";
+import"./index-w1avzkdt.js";
 import"./index-135e8hvg.js";
 import"./index-8976mezv.js";
-import"./index-d4dt19md.js";
+import"./index-hqw0rt9k.js";
 
 // ../plugin/src/features/magic-context/chunk-embedding-write-worker.ts
 import { parentPort, workerData } from "node:worker_threads";
@@ -51,24 +55,27 @@ if (!enforceSchemaFence(db, workerData.path, LATEST_SUPPORTED_VERSION)) {
 var timeout = Math.max(0, Math.floor(workerData.timeout));
 db.exec(`PRAGMA busy_timeout=${timeout}; PRAGMA foreign_keys=ON`);
 configureContextDatabasePragmas2(db);
+exitOnWorkerClose(port, () => db.close());
 port.on("message", (input) => {
+  if (isWorkerCloseMessage(input))
+    return;
   try {
     let value;
     switch (input.kind) {
       case "replace":
-        replaceCompartmentChunkEmbeddings(db, input.rows, input.sourceKey);
+        replaceCompartmentChunkEmbeddings2(db, input.rows, input.sourceKey);
         break;
       case "project":
         recordSessionProjectIdentity(db, input.session, input.project);
         break;
       case "count":
-        value = countUnembeddedSessionCompartments(db, input.project, input.session, input.model, input.tokens);
+        value = countUnembeddedSessionCompartments2(db, input.project, input.session, input.model, input.tokens);
         break;
       case "candidates":
-        value = loadUnembeddedSessionChunkCandidates(db, input.project, input.session, input.model, input.limit, input.excluded, input.tokens, true);
+        value = loadUnembeddedSessionChunkCandidates2(db, input.project, input.session, input.model, input.limit, input.excluded, input.tokens, true);
         break;
       case "backoff":
-        recordChunkEmbedBackoff(db, input.candidate, input.project, input.model);
+        recordChunkEmbedBackoff2(db, input.candidate, input.project, input.model);
         break;
       case "acquire":
         value = acquireGitSweepLease(db, input.project, input.holder, {

package/dist/{compaction-marker-candidates-wjzqbspm.js → compaction-marker-candidates-p1kqkqhq.js}

@@ -4,10 +4,10 @@ import {
   readMarkerCandidateBasis2,
   prepareMarkerCandidateBasis2,
   scanMarkerCandidateSnapshot2
-} from "./index-qpq6w67c.js";
+} from "./index-6wdwv3a6.js";
 import"./index-399p688g.js";
-import"./index-rrwv9y2k.js";
-import"./index-7bqrfyny.js";
+import"./index-2qtx0q6h.js";
+import"./index-fgs78jyd.js";
 import"./index-0h2mkab2.js";
 export {
   invalidateMarkerCandidateBasis2 as invalidateMarkerCandidateBasis,

package/dist/compaction-marker-candidates-worker.js

@@ -5,8 +5,8 @@ if (!port)
   throw new Error("marker candidate worker requires a parent port");
 port.postMessage({ kind: "accepted" });
 var [{ Database }, { scanMarkerCandidateSnapshot }] = await Promise.all([
-  import("./sqlite-fsp0sf3r.js"),
-  import("./compaction-marker-candidates-wjzqbspm.js")
+  import("./sqlite-v89bj0yy.js"),
+  import("./compaction-marker-candidates-p1kqkqhq.js")
 ]);
 var input = workerData;
 var db;

package/dist/compartment-chunk-embedding-y01m95c2.js

@@ -0,0 +1,64 @@
+import {
+  DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS2,
+  CHUNK_WINDOW_SAFETY_RATIO2,
+  normalizeCompartmentChunkMaxInputTokens2,
+  buildCanonicalChunkTextFromFts2,
+  buildCompartmentSummaryFallbackText2,
+  canonicalizeInMemoryChunkTextForEmbedding2,
+  chunkCanonicalText2,
+  chunkEmbeddingWindowsAreCurrent2,
+  replaceCompartmentChunkEmbeddings2,
+  loadCompartmentChunkEmbeddingsForSearch2,
+  getLastCompartmentChunkPoolWarm2,
+  peekCompartmentChunkSearchPool2,
+  warmCompartmentChunkSearchPool2,
+  maintainCompartmentChunkSearchPools2,
+  loadUnembeddedShadowChunkCandidates2,
+  loadUnembeddedCompartmentChunkCandidatesPolite2,
+  deleteChunkEmbedBackoffForSession2,
+  recordChunkEmbedBackoff2,
+  chunkWindowSourceKey2,
+  loadUnembeddedSessionChunkCandidates2,
+  loadUnembeddedSessionChunkCandidatesPolite2,
+  countUnembeddedSessionCompartments2,
+  countSessionCompartmentEmbedCoverage2,
+  countSessionCompartmentEmbedCoveragePolite2,
+  countUnembeddedSessionCompartmentsPolite2
+} from "./index-vx6f7wff.js";
+import"./index-gwxaz0z5.js";
+import"./index-579m1751.js";
+import"./index-at6py2k3.js";
+import"./index-399p688g.js";
+import"./index-hqw0rt9k.js";
+import"./index-my0dn413.js";
+import"./index-2qtx0q6h.js";
+import"./index-fgs78jyd.js";
+import"./index-0h2mkab2.js";
+import"./index-54wmg4rj.js";
+export {
+  CHUNK_WINDOW_SAFETY_RATIO2 as CHUNK_WINDOW_SAFETY_RATIO,
+  DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS2 as DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS,
+  buildCanonicalChunkTextFromFts2 as buildCanonicalChunkTextFromFts,
+  buildCompartmentSummaryFallbackText2 as buildCompartmentSummaryFallbackText,
+  canonicalizeInMemoryChunkTextForEmbedding2 as canonicalizeInMemoryChunkTextForEmbedding,
+  chunkCanonicalText2 as chunkCanonicalText,
+  chunkEmbeddingWindowsAreCurrent2 as chunkEmbeddingWindowsAreCurrent,
+  chunkWindowSourceKey2 as chunkWindowSourceKey,
+  countSessionCompartmentEmbedCoverage2 as countSessionCompartmentEmbedCoverage,
+  countSessionCompartmentEmbedCoveragePolite2 as countSessionCompartmentEmbedCoveragePolite,
+  countUnembeddedSessionCompartments2 as countUnembeddedSessionCompartments,
+  countUnembeddedSessionCompartmentsPolite2 as countUnembeddedSessionCompartmentsPolite,
+  deleteChunkEmbedBackoffForSession2 as deleteChunkEmbedBackoffForSession,
+  getLastCompartmentChunkPoolWarm2 as getLastCompartmentChunkPoolWarm,
+  loadCompartmentChunkEmbeddingsForSearch2 as loadCompartmentChunkEmbeddingsForSearch,
+  loadUnembeddedCompartmentChunkCandidatesPolite2 as loadUnembeddedCompartmentChunkCandidatesPolite,
+  loadUnembeddedSessionChunkCandidates2 as loadUnembeddedSessionChunkCandidates,
+  loadUnembeddedSessionChunkCandidatesPolite2 as loadUnembeddedSessionChunkCandidatesPolite,
+  loadUnembeddedShadowChunkCandidates2 as loadUnembeddedShadowChunkCandidates,
+  maintainCompartmentChunkSearchPools2 as maintainCompartmentChunkSearchPools,
+  normalizeCompartmentChunkMaxInputTokens2 as normalizeCompartmentChunkMaxInputTokens,
+  peekCompartmentChunkSearchPool2 as peekCompartmentChunkSearchPool,
+  recordChunkEmbedBackoff2 as recordChunkEmbedBackoff,
+  replaceCompartmentChunkEmbeddings2 as replaceCompartmentChunkEmbeddings,
+  warmCompartmentChunkSearchPool2 as warmCompartmentChunkSearchPool
+};

package/dist/embedding-backfill-2vh6m3bg.js

@@ -0,0 +1,24 @@
+import {
+  ensureMemoryEmbeddings2
+} from "./index-pe5gz5c4.js";
+import"./index-w1twp2kp.js";
+import"./index-9p40dgkm.js";
+import"./index-yhzhdp3m.js";
+import"./index-j3pz3a1b.js";
+import"./index-vx6f7wff.js";
+import"./index-wqpjhx1p.js";
+import"./index-gwxaz0z5.js";
+import"./index-ccanzg8p.js";
+import"./index-hxp6q5f8.js";
+import"./index-579m1751.js";
+import"./index-at6py2k3.js";
+import"./index-399p688g.js";
+import"./index-hqw0rt9k.js";
+import"./index-my0dn413.js";
+import"./index-2qtx0q6h.js";
+import"./index-fgs78jyd.js";
+import"./index-0h2mkab2.js";
+import"./index-54wmg4rj.js";
+export {
+  ensureMemoryEmbeddings2 as ensureMemoryEmbeddings
+};

package/dist/embedding-worker-process.js

@@ -1,10 +1,10 @@
 import"./index-0h2mkab2.js";
 import {
   log2
-} from "./index-7bqrfyny.js";
+} from "./index-fgs78jyd.js";
 import {
   inRootAsyncContext2
-} from "./index-rrwv9y2k.js";
+} from "./index-2qtx0q6h.js";
 
 // ../plugin/src/features/magic-context/memory/embedding-worker-process.ts
 import { Worker } from "node:worker_threads";

package/dist/embedding-worker.js

@@ -3,16 +3,16 @@ import {
 } from "./index-0h2mkab2.js";
 import {
   log2
-} from "./index-7bqrfyny.js";
-import"./index-bxmf4dhr.js";
-import"./index-d8gc0112.js";
-import"./index-1kcfwk9c.js";
-import"./index-rrwv9y2k.js";
+} from "./index-fgs78jyd.js";
+import"./index-ccanzg8p.js";
+import"./index-gwxaz0z5.js";
+import"./index-my0dn413.js";
+import"./index-2qtx0q6h.js";
 import {
   resolveLocalEmbeddingWorkerRuntime,
   getLocalEmbeddingNativeMemoryStats,
   LocalEmbeddingProvider
-} from "./index-2mmy81qt.js";
+} from "./index-wqpjhx1p.js";
 import {
   setStoragePrivatePermissionEnforcement
 } from "./index-81nthk8j.js";

package/dist/historian-calibration-extension.js

@@ -10,7 +10,7 @@ import {
 } from "./index-fa485mqs.js";
 import"./index-4knyh1kt.js";
 import"./index-6x556c2q.js";
-import"./index-7bqrfyny.js";
+import"./index-fgs78jyd.js";
 import"./index-0h2mkab2.js";
 export {
   HISTORIAN_CACHE_TAIL_ENV2 as HISTORIAN_CACHE_TAIL_ENV,

package/dist/{index-e1rza8gp.js → index-29nw7n1r.js}

@@ -1,6 +1,6 @@
 import {
   withPrivilegedWriter2
-} from "./index-rrwv9y2k.js";
+} from "./index-2qtx0q6h.js";
 import {
   MEMORY_CATEGORY_ORDER_SQL
 } from "./index-135e8hvg.js";

package/dist/{index-rrwv9y2k.js → index-2qtx0q6h.js}

@@ -174,6 +174,177 @@ function topLevelCommaSegments(text) {
 function getTagIdentityWriteGeneration2() {
   return tagIdentityWriteGeneration;
 }
+var busyTimeoutStates = new WeakMap;
+var BUSY_TIMEOUT_QUERY = /^\s*PRAGMA\s+(?:(?:\w+|"[^"]+"|`[^`]+`|\[[^\]]+\])\s*\.\s*)?(?:busy_timeout|"busy_timeout"|`busy_timeout`|\[busy_timeout\])\s*;?\s*$/i;
+var BUSY_TIMEOUT_SETTER = /^\s*PRAGMA\s+(?:(?:\w+|"[^"]+"|`[^`]+`|\[[^\]]+\])\s*\.\s*)?(?:busy_timeout|"busy_timeout"|`busy_timeout`|\[busy_timeout\])\s*(?==|\()/i;
+function literalBusyTimeout(sql) {
+  const head = BUSY_TIMEOUT_SETTER.exec(sql);
+  if (!head)
+    return;
+  const match = /^(?:=\s*|\(\s*)(?:'(-?\d+)'|"(-?\d+)"|(-?\d+))\s*\)?\s*;?\s*$/.exec(sql.slice(head[0].length));
+  if (!match)
+    return;
+  const value = Number(match[1] ?? match[2] ?? match[3]);
+  return value < 0 ? 0 : value <= 2147483647 ? value : undefined;
+}
+function busyTimeoutStatements(sql) {
+  const statements = [];
+  let statement = "";
+  let quote = "";
+  for (let i = 0;i < sql.length; i++) {
+    const char = sql[i];
+    if (quote) {
+      statement += char;
+      if (char === quote) {
+        if (sql[i + 1] === quote)
+          statement += sql[++i];
+        else
+          quote = "";
+      }
+    } else if (char === "'" || char === '"' || char === "`" || char === "[") {
+      quote = char === "[" ? "]" : char;
+      statement += char;
+    } else if (char === "-" && sql[i + 1] === "-") {
+      while (i + 1 < sql.length && sql[i + 1] !== `
+`)
+        i++;
+      statement += " ";
+    } else if (char === "/" && sql[i + 1] === "*") {
+      i += 2;
+      while (i < sql.length && !(sql[i] === "*" && sql[i + 1] === "/"))
+        i++;
+      i++;
+      statement += " ";
+    } else if (char === ";") {
+      statements.push(statement);
+      statement = "";
+    } else
+      statement += char;
+  }
+  statements.push(statement);
+  return statements.filter((part) => part.trim().length > 0);
+}
+function installNativeDeadlineRouting(db) {
+  const rawExec = db.exec.bind(db);
+  const rawPrepare = db.prepare.bind(db);
+  const readTimeout = () => {
+    const statement = rawPrepare("PRAGMA busy_timeout");
+    try {
+      return Object.values(statement.get())[0];
+    } finally {
+      statement.finalize?.();
+    }
+  };
+  const timeoutState = { current: readTimeout() };
+  busyTimeoutStates.set(db, timeoutState);
+  const setBusyTimeout = (timeout) => {
+    rawExec(`PRAGMA busy_timeout=${timeout}`);
+    timeoutState.current = timeout;
+  };
+  const withinDeadline = (operation) => {
+    const deadline = nativeWaitScope?.getStore();
+    if (!deadline?.active || !deadline.remainingMs)
+      return operation();
+    const remaining = deadline.remainingMs();
+    if (remaining === Infinity)
+      return operation();
+    const previous = timeoutState.current;
+    const timeout = Math.min(previous, Math.max(0, Math.floor(remaining)));
+    if (timeout === previous)
+      return operation();
+    setBusyTimeout(timeout);
+    try {
+      return operation();
+    } finally {
+      setBusyTimeout(previous);
+    }
+  };
+  Object.defineProperty(db, "exec", {
+    configurable: true,
+    writable: true,
+    value: (sql) => {
+      const parts = /\bbusy_timeout\b/i.test(sql) ? busyTimeoutStatements(sql) : [];
+      if (parts.length === 1 && BUSY_TIMEOUT_QUERY.test(parts[0]))
+        return rawExec(sql);
+      const singleSetter = parts.length === 1 && BUSY_TIMEOUT_SETTER.test(parts[0]);
+      const setting = singleSetter ? literalBusyTimeout(parts[0]) : undefined;
+      if (singleSetter) {
+        const result = rawExec(sql);
+        timeoutState.current = setting ?? readTimeout();
+        return result;
+      }
+      if (!/\bbusy_timeout\b/i.test(sql))
+        return withinDeadline(() => rawExec(sql));
+      const setters = parts.filter((part) => BUSY_TIMEOUT_SETTER.test(part));
+      return withinDeadline(() => {
+        try {
+          const result = rawExec(sql);
+          if (setters.length)
+            timeoutState.current = literalBusyTimeout(setters[setters.length - 1]) ?? readTimeout();
+          return result;
+        } catch (error) {
+          if (setters.length)
+            timeoutState.current = readTimeout();
+          throw error;
+        }
+      });
+    }
+  });
+  const nativePrepare = (sql) => BUSY_TIMEOUT_QUERY.test(sql) || BUSY_TIMEOUT_SETTER.test(sql) ? rawPrepare(sql) : withinDeadline(() => rawPrepare(sql));
+  Object.defineProperty(db, "prepare", {
+    configurable: true,
+    writable: true,
+    value: (sql) => {
+      const statement = nativePrepare(sql);
+      const normalized = /\bbusy_timeout\b/i.test(sql) ? busyTimeoutStatements(sql)[0] ?? sql : sql;
+      const setting = literalBusyTimeout(normalized);
+      const timeoutSetter = BUSY_TIMEOUT_SETTER.test(normalized);
+      const timeoutQuery = BUSY_TIMEOUT_QUERY.test(normalized);
+      if (timeoutSetter)
+        timeoutState.current = setting ?? readTimeout();
+      for (const method of ["run", "get", "all", "values"]) {
+        const execute = statement[method]?.bind(statement);
+        if (!execute)
+          continue;
+        Object.defineProperty(statement, method, {
+          configurable: true,
+          value: (...args) => {
+            if (timeoutQuery)
+              return execute(...args);
+            if (!timeoutSetter)
+              return withinDeadline(() => execute(...args));
+            const result = execute(...args);
+            timeoutState.current = readTimeout();
+            return result;
+          }
+        });
+      }
+      if (typeof statement.iterate === "function") {
+        const iterate = statement.iterate.bind(statement);
+        Object.defineProperty(statement, "iterate", {
+          configurable: true,
+          value: (...args) => {
+            const iterator = !timeoutSetter && !timeoutQuery ? withinDeadline(() => iterate(...args)) : iterate(...args);
+            const next = iterator.next.bind(iterator);
+            if (timeoutSetter)
+              timeoutState.current = readTimeout();
+            iterator.next = () => {
+              if (timeoutQuery)
+                return next();
+              if (!timeoutSetter)
+                return withinDeadline(next);
+              const result = next();
+              timeoutState.current = readTimeout();
+              return result;
+            };
+            return iterator;
+          }
+        });
+      }
+      return statement;
+    }
+  });
+}
 function installTransactionRouting(db, readonly) {
   const nativeExec = db.exec.bind(db);
   Object.defineProperty(db, "exec", {
@@ -311,7 +482,7 @@ function wrapRemainingTagWriteForms(statement) {
     });
   }
 }
-function trackSqliteConnection(db, filename, options) {
+function trackSqliteConnection(db, filename, options, turnDeadlines = false) {
   const originalClose = db.close.bind(db);
   const sequence = nextSqliteConnectionSequence++;
   const metadata = {
@@ -319,6 +490,8 @@ function trackSqliteConnection(db, filename, options) {
     filename: typeof filename === "string" ? filename : Buffer.isBuffer(filename) ? "<buffer>" : ":memory:",
     readonly: Boolean(options) && typeof options === "object" && (options.readonly === true || options.readOnly === true)
   };
+  if (turnDeadlines)
+    installNativeDeadlineRouting(db);
   installTransactionRouting(db, metadata.readonly);
   Object.defineProperty(db, "close", {
     configurable: true,
@@ -371,6 +544,12 @@ function buildNodeSqliteDatabaseClass(DatabaseSync) {
   return NodeSqliteDatabase;
 }
 var Database2 = TrackedDatabase;
+function createSqliteTurnDatabase2(filename, options) {
+  return trackSqliteConnection(new DatabaseImpl(filename, options), filename, options, true);
+}
+function hasSqliteTurnDeadlineRouting2(db) {
+  return busyTimeoutStates.has(db);
+}
 function getSqliteDatabasePath2(db) {
   for (const connection of trackedSqliteConnections.values()) {
     if (connection.reference.deref() === db) {
@@ -390,6 +569,11 @@ function pragmaValue(db, name) {
   return row[name] ?? Object.values(row)[0];
 }
 function pragmaNumber(db, name) {
+  if (name === "busy_timeout") {
+    const state = busyTimeoutStates.get(db);
+    if (state)
+      return state.current;
+  }
   try {
     const value = pragmaValue(db, name);
     return typeof value === "number" && Number.isFinite(value) ? value : null;
@@ -455,11 +639,34 @@ function prepareCachedStatement2(db, sql) {
   return ownPreparedStatement(db, db.prepare(sql));
 }
 var privilegeDepth = new WeakMap;
+var nativeWaitScope;
+function releaseNativeWaitLease(lease) {
+  lease.active = false;
+  lease.remainingMs = undefined;
+}
+function withSqliteTurnDeadline2(remainingMs, operation) {
+  const scope = nativeWaitScope ??= new AsyncLocalStorage;
+  const lease = { active: true, remainingMs };
+  return scope.run(lease, () => {
+    try {
+      const result = operation();
+      if (result && typeof result.then === "function")
+        return Promise.resolve(result).finally(releaseNativeWaitLease.bind(null, lease));
+      releaseNativeWaitLease(lease);
+      return result;
+    } catch (error) {
+      releaseNativeWaitLease(lease);
+      throw error;
+    }
+  });
+}
 var transformPassScope = new AsyncLocalStorage;
 var admissionScope = new AsyncLocalStorage;
 var backgroundWriterScope = new AsyncLocalStorage;
 function withSqliteBackgroundWriter2(operation) {
-  return backgroundWriterScope.run(true, operation);
+  if (!nativeWaitScope?.getStore())
+    return backgroundWriterScope.run(true, operation);
+  return nativeWaitScope.run(undefined, () => backgroundWriterScope.run(true, operation));
 }
 function withSqliteTransformPass2(operation) {
   const existing = transformPassScope.getStore();
@@ -490,7 +697,9 @@ function withSqliteTransformPass2(operation) {
   return typeof reservation === "function" ? run(reservation) : reservation.then(run);
 }
 function withoutSqliteTransformPass2(operation) {
-  return transformPassScope.run(undefined, operation);
+  if (!nativeWaitScope?.getStore())
+    return transformPassScope.run(undefined, operation);
+  return nativeWaitScope.run(undefined, () => transformPassScope.run(undefined, operation));
 }
 function guardSqliteTransformPass2(guard) {
   const lease = transformPassScope.getStore();
@@ -691,7 +900,7 @@ async function withAsyncPrivilegedWriter2(db, operation, options = {}) {
     } catch (error) {
       if (entered || !(error instanceof SqliteAcquisitionBusyError))
         throw error;
-      options.beforeRetry?.(error);
+      await options.beforeRetry?.(error);
       const elapsed = performance.now() - started;
       if (elapsed >= budgetMs) {
         reportSqliteDiagnostic(`sqlite writer site=privileged_writer lane=foreground acquire_ms=${Math.round(elapsed)} attempts=${attempts} outcome=busy`);
@@ -829,4 +1038,4 @@ async function yieldIndexChunk2() {
   await yieldIndexTurn();
 }
 
-export { inRootAsyncContext2, registerSlowWriteReporter2, registerSqliteDiagnosticSink2, detectSqliteRuntime2, getTagIdentityWriteGeneration2, Database2, getSqliteDatabasePath2, prepareCachedStatement2, withSqliteBackgroundWriter2, withSqliteTransformPass2, withoutSqliteTransformPass2, guardSqliteTransformPass2, assertTransformWrite2, isTransientSqliteError2, beginSqliteWriterAsync2, withAsyncPrivilegedWriter2, withPrivilegedWriter2, indexCoordinationInput2, releaseIndexOwner2, withIndexChunk2, yieldIndexChunk2 };
+export { inRootAsyncContext2, registerSlowWriteReporter2, registerSqliteDiagnosticSink2, detectSqliteRuntime2, getTagIdentityWriteGeneration2, Database2, createSqliteTurnDatabase2, hasSqliteTurnDeadlineRouting2, getSqliteDatabasePath2, prepareCachedStatement2, withSqliteTurnDeadline2, withSqliteBackgroundWriter2, withSqliteTransformPass2, withoutSqliteTransformPass2, guardSqliteTransformPass2, assertTransformWrite2, isTransientSqliteError2, beginSqliteWriterAsync2, withAsyncPrivilegedWriter2, withPrivilegedWriter2, indexCoordinationInput2, releaseIndexOwner2, withIndexChunk2, yieldIndexChunk2 };