@cortexkit/pi-magic-context 0.49.20 → 0.49.22

package/dist/{index-hws5f0z9.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();
@@ -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 };

package/dist/{index-5vgt1zeh.js → index-3c3ztwgc.js}

@@ -16,11 +16,11 @@ import {
 } from "./index-8976mezv.js";
 import {
   Database2
-} from "./index-hws5f0z9.js";
+} from "./index-2qtx0q6h.js";
 import {
   normalizeStoredProjectPath,
   storedPathBelongsToIdentity
-} from "./index-p63nwn5v.js";
+} from "./index-hxp6q5f8.js";
 import {
   logSlowWriteTransaction
 } from "./index-hqw0rt9k.js";

package/dist/{index-rgfb753z.js → index-579m1751.js}

@@ -2,10 +2,10 @@ import {
   getSqliteDatabasePath2,
   withSqliteBackgroundWriter2,
   withoutSqliteTransformPass2
-} from "./index-hws5f0z9.js";
+} from "./index-2qtx0q6h.js";
 import {
   runSessionWarmupWorker
-} from "./index-rfyvax95.js";
+} from "./index-at6py2k3.js";
 import {
   logSlowWriteTransaction
 } from "./index-hqw0rt9k.js";

package/dist/{index-kqb3d8bs.js → index-5j6vwg4z.js}

@@ -7,18 +7,136 @@ import {
 import {
   getTagsBySession2,
   getTagsByNumbers2
-} from "./index-bttctq07.js";
+} from "./index-n8e5e9fp.js";
 import {
   inRootAsyncContext2,
-  getSqliteDatabasePath2
-} from "./index-hws5f0z9.js";
+  getSqliteDatabasePath2,
+  withSqliteTurnDeadline2
+} from "./index-2qtx0q6h.js";
 import {
   createFailClosedBlockingError
-} from "./index-mtvvhcw4.js";
+} from "./index-dbgg6hsf.js";
 import {
   createWorkerShutdown
 } from "./index-54wmg4rj.js";
 
+// src/pi-context-budget.ts
+var PI_CONTEXT_BUDGET = {
+  hostDeadlineMs: 30000,
+  hostMarginMs: 5000,
+  outcomeMs: 25000,
+  fallbackObservedMs: 4,
+  workMs: 21000,
+  writerMs: 16500,
+  completionReserveMs: 2000,
+  searchMs: 3000
+};
+
+class PiContextDeadlineError extends Error {
+}
+
+class PiContextSupersededError extends Error {
+  origin;
+  constructor(message, origin = "context ownership") {
+    super(message);
+    this.origin = origin;
+  }
+}
+
+class PiContextBudget {
+  startedAt;
+  now;
+  sideTurn = false;
+  stage = "entry";
+  recovery = "not attempted";
+  abandoned = false;
+  completed = false;
+  failureReason;
+  signal;
+  cancelled = false;
+  isCancelled(error) {
+    return this.cancelled || this.signal?.aborted === true || !this.signal && typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
+  }
+  cancel() {
+    this.cancelled = true;
+    this.abandoned = true;
+    this.completed = false;
+    this.failureReason = undefined;
+  }
+  assertOwner = () => {};
+  constructor(startedAt = performance.now(), now = () => performance.now()) {
+    this.startedAt = startedAt;
+    this.now = now;
+  }
+  elapsed() {
+    return this.now() - this.startedAt;
+  }
+  remainingWork = () => {
+    return Math.max(0, PI_CONTEXT_BUDGET.workMs - this.elapsed());
+  };
+  remainingOutcome = () => Math.max(0, PI_CONTEXT_BUDGET.outcomeMs - this.elapsed());
+  writerAllowance() {
+    return Math.max(0, Math.min(PI_CONTEXT_BUDGET.writerMs, this.remainingWork() - PI_CONTEXT_BUDGET.completionReserveMs));
+  }
+  hydrationAllowance() {
+    return Math.max(0, Math.min(this.remainingWork() - PI_CONTEXT_BUDGET.completionReserveMs, this.remainingOutcome() - PI_CONTEXT_BUDGET.completionReserveMs));
+  }
+  assertOutcome = () => {
+    this.assertOwner();
+    this.signal?.throwIfAborted();
+    if (this.abandoned || this.elapsed() >= PI_CONTEXT_BUDGET.outcomeMs)
+      throw new PiContextDeadlineError(this.diagnostic());
+  };
+  assert = () => {
+    this.assertOutcome();
+    if (this.elapsed() >= PI_CONTEXT_BUDGET.workMs)
+      throw new PiContextDeadlineError(this.diagnostic());
+  };
+  assertDecisionPublication = () => {
+    this.signal?.throwIfAborted();
+    if (!this.completed)
+      this.assertOwner();
+    if (this.abandoned || !this.completed && this.elapsed() >= PI_CONTEXT_BUDGET.outcomeMs)
+      throw new PiContextDeadlineError(this.diagnostic());
+  };
+  diagnostic() {
+    return `stage=${this.stage} elapsed=${Math.round(this.elapsed())}ms recovery=${this.recovery}`;
+  }
+  waitUntil = async (pending, assert, remaining) => {
+    try {
+      assert();
+    } catch (error) {
+      pending.catch(() => {});
+      throw error;
+    }
+    let timer;
+    let onAbort;
+    try {
+      return await Promise.race([
+        pending,
+        ...this.signal ? [
+          new Promise((_, reject) => {
+            onAbort = () => reject(this.signal?.reason);
+            this.signal?.addEventListener("abort", onAbort, {
+              once: true
+            });
+          })
+        ] : [],
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new PiContextDeadlineError(this.diagnostic())), remaining());
+        })
+      ]);
+    } finally {
+      clearTimeout(timer);
+      if (onAbort)
+        this.signal?.removeEventListener("abort", onAbort);
+      assert();
+    }
+  };
+  wait = (pending) => this.waitUntil(pending, this.assert, () => this.remainingWork());
+  waitMandatory = (pending) => this.waitUntil(pending, this.assertOutcome, this.remainingOutcome);
+}
+
 // src/tag-snapshot-worker-client-pi.ts
 import { setImmediate as yieldImmediate } from "node:timers/promises";
 import { Worker } from "node:worker_threads";
@@ -310,6 +428,13 @@ function createPiTagSnapshotReader(db) {
   const existing = readers.get(db);
   if (existing)
     return existing;
+  const nativeWaiters = new Set;
+  const inSnapshotRoot = (operation) => inRootAsyncContext2(() => withSqliteTurnDeadline2(() => {
+    let remaining = Infinity;
+    for (const waiter of nativeWaiters)
+      remaining = Math.min(remaining, waiter());
+    return remaining;
+  }, operation));
   db.exec(`
 		CREATE TEMP TABLE IF NOT EXISTS pi_tag_revision (revision INTEGER NOT NULL);
 		INSERT INTO pi_tag_revision SELECT 0 WHERE NOT EXISTS (SELECT 1 FROM pi_tag_revision);
@@ -403,7 +528,8 @@ function createPiTagSnapshotReader(db) {
   const ownFirstAllocation = db.prepare(`SELECT 1 FROM pi_tag_first_allocation allocation
 		WHERE session_id = ? AND seen = 1 AND incarnation || ':0' = ?
 		AND EXISTS (SELECT 1 FROM pi_tag_watch WHERE session_id = allocation.session_id)
-		AND EXISTS (SELECT 1 FROM pi_tag_first_rows WHERE session_id = allocation.session_id)
+		AND EXISTS (SELECT 1 FROM pi_tag_changes WHERE session_id = allocation.session_id)
+		AND (? = 'legacy' OR EXISTS (SELECT 1 FROM pi_tag_first_rows WHERE session_id = allocation.session_id))
 		AND NOT EXISTS (SELECT 1 FROM pi_tag_first_rows first_row WHERE first_row.session_id = allocation.session_id
 		AND NOT EXISTS (SELECT 1 FROM pi_tag_changes change WHERE change.session_id = first_row.session_id AND change.tag_number IS first_row.tag_number))`);
   const managed = new Set;
@@ -414,6 +540,7 @@ function createPiTagSnapshotReader(db) {
   let desiredSession;
   let failedUntil = 0;
   let lastFailure;
+  let failedSession;
   const totalRevision = db.prepare("SELECT COALESCE(value, '0') AS revision, value IS NOT NULL AS present FROM (SELECT 1) LEFT JOIN schema_migrations_meta ON key = ?");
   const assertOutsideTransaction = () => {
     const connection = db;
@@ -458,7 +585,7 @@ function createPiTagSnapshotReader(db) {
     if (current?.sessionId === sessionId)
       current.cancel();
   };
-  const load = (sessionId) => inRootAsyncContext2(async () => {
+  const load = (sessionId) => inSnapshotRoot(async () => {
     managed.add(sessionId);
     if (ready(sessionId))
       return;
@@ -472,7 +599,7 @@ function createPiTagSnapshotReader(db) {
         throw new PiTagHydrationError("session hydration superseded", "stale");
       return load(sessionId);
     }
-    if (performance.now() < failedUntil)
+    if (failedSession === sessionId && performance.now() < failedUntil)
       throw lastFailure;
     watch.run(sessionId);
     const token = stamps(sessionId, ++jobId);
@@ -516,7 +643,7 @@ function createPiTagSnapshotReader(db) {
       if (current !== destination || desiredSession !== sessionId || !samePiTagSnapshotToken(token, live) || token.totalRevision !== live.totalRevision || generation.revision !== token.totalRevision || generation.durable !== token.durableVersion)
         throw new PiTagHydrationError("owner generation or lifetime changed", "stale");
       const snapshot = {
-        firstAllocationPending: !live.revisionPresent && candidate.tags.length === 0 && !db.prepare("SELECT 1 FROM tags WHERE session_id = ? LIMIT 1").get(sessionId),
+        firstAllocationPending: live.revisionPresent ? undefined : candidate.tags.length === 0 && !db.prepare("SELECT 1 FROM tags WHERE session_id = ? LIMIT 1").get(sessionId) ? "empty" : "legacy",
         revision: legacyFallbackOnly ? previous.revision : live.localRevision,
         foreignRevision: live.foreignRevision,
         tags: legacyFallbackOnly ? previous.tags : candidate.tags,
@@ -545,6 +672,7 @@ function createPiTagSnapshotReader(db) {
       if (error instanceof PiTagHydrationError && error.code === "stale")
         destination.stale = true;
       if (current === destination && desiredSession === sessionId && token.sessionEpoch === (sessionEpochs.get(sessionId) ?? 0)) {
+        failedSession = sessionId;
         lastFailure = error;
         failedUntil = performance.now() + (error instanceof PiTagHydrationError && error.code === "stale" ? 0 : 500);
       }
@@ -562,6 +690,12 @@ function createPiTagSnapshotReader(db) {
   owners.set(db, {
     ready,
     load,
+    addNativeWaiter: (remaining) => {
+      nativeWaiters.add(remaining);
+      return () => {
+        nativeWaiters.delete(remaining);
+      };
+    },
     manage: (sessionId) => managed.add(sessionId),
     cancel
   });
@@ -578,9 +712,9 @@ function createPiTagSnapshotReader(db) {
     ];
     const stamp = versionStamp.get(sessionId, sessionId);
     let snapshot = cache.get(sessionId);
-    if (snapshot?.firstAllocationPending && snapshot.foreignRevision !== external && snapshot.revision !== local && stamp.durable - snapshot.durableVersion === stamp.own - snapshot.ownVersion && ownFirstAllocation.get(sessionId, external)) {
+    if (snapshot?.firstAllocationPending && snapshot.foreignRevision !== external && snapshot.revision !== local && stamp.durable - snapshot.durableVersion === stamp.own - snapshot.ownVersion && ownFirstAllocation.get(sessionId, external, snapshot.firstAllocationPending)) {
       snapshot.foreignRevision = external;
-      snapshot.firstAllocationPending = false;
+      snapshot.firstAllocationPending = undefined;
       db.prepare("DELETE FROM pi_tag_first_watch WHERE session_id = ?").run(sessionId);
       db.prepare("DELETE FROM pi_tag_first_rows WHERE session_id = ?").run(sessionId);
     }
@@ -662,6 +796,7 @@ function createPiTagSnapshotReader(db) {
     writable: true,
     value: (...args) => {
       desiredSession = undefined;
+      nativeWaiters.clear();
       current?.cancel();
       cache.clear();
       entryReaders.delete(db);
@@ -885,6 +1020,7 @@ function ensurePiTagSnapshotReady(db, sessionId, budget) {
       if (allowance <= 0)
         throw new PiTagHydrationError("remaining pass budget exhausted waiting for tag snapshot; turn not sent, retry", "deadline");
       let timer;
+      const releaseNativeWaiter = owner.addNativeWaiter(() => budget.remainingOutcome() - PI_CONTEXT_BUDGET.completionReserveMs);
       try {
         await budget.wait(Promise.race([
           owner.load(sessionId),
@@ -901,9 +1037,10 @@ function ensurePiTagSnapshotReady(db, sessionId, budget) {
           throw error;
       } finally {
         clearTimeout(timer);
+        releaseNativeWaiter();
       }
     }
   })();
 }
 
-export { encodePiHydrationOperation, PiTagHydrationError, PI_FALLBACK_ROW_COLUMNS, PI_FALLBACK_ROW_PREDICATE, getPiTagSnapshotView, getPiActiveTagSnapshotView, readPiFallbackTagRows, prewarmPiTagSnapshot, cancelPiTagSnapshotSession, drainPiTagSnapshotSession, assertPiTagSnapshotReady, ensurePiTagSnapshotReady };
+export { PI_CONTEXT_BUDGET, PiContextDeadlineError, PiContextSupersededError, PiContextBudget, encodePiHydrationOperation, PiTagHydrationError, PI_FALLBACK_ROW_COLUMNS, PI_FALLBACK_ROW_PREDICATE, getPiTagSnapshotView, getPiActiveTagSnapshotView, readPiFallbackTagRows, prewarmPiTagSnapshot, cancelPiTagSnapshotSession, drainPiTagSnapshotSession, assertPiTagSnapshotReady, ensurePiTagSnapshotReady };

package/dist/{index-6kb2xpw7.js → index-6wdwv3a6.js}

@@ -7,7 +7,7 @@ import {
 import {
   inRootAsyncContext2,
   getSqliteDatabasePath2
-} from "./index-hws5f0z9.js";
+} from "./index-2qtx0q6h.js";
 
 // ../plugin/src/features/magic-context/compaction-marker-candidates.ts
 import { existsSync, realpathSync } from "node:fs";

package/dist/{index-rfyvax95.js → index-at6py2k3.js}

@@ -2,7 +2,7 @@ import {
   inRootAsyncContext2,
   getSqliteDatabasePath2,
   releaseIndexOwner2
-} from "./index-hws5f0z9.js";
+} from "./index-2qtx0q6h.js";
 import {
   registerExitAbort
 } from "./index-399p688g.js";