@cortexkit/pi-magic-context 0.49.30 → 0.49.32

package/dist/{index-2pnhk4gc.js → index-drmr22ac.js}

@@ -3,11 +3,11 @@ import {
   tagRevisionCountSql,
   tagRevisionKey,
   TAG_INSERT_CONFLICT_ROWS
-} from "./index-g026ztby.js";
+} from "./index-c474g0gj.js";
 import {
   getTagsBySession2,
   getTagsByNumbers2
-} from "./index-0x1c054v.js";
+} from "./index-eqw9t2ty.js";
 import {
   inRootAsyncContext2,
   getSqliteDatabasePath2,
@@ -15,7 +15,7 @@ import {
 } from "./index-2qtx0q6h.js";
 import {
   createFailClosedBlockingError
-} from "./index-y5x5wt5t.js";
+} from "./index-r9y6tbbm.js";
 import {
   createWorkerShutdown
 } from "./index-54wmg4rj.js";
@@ -189,8 +189,8 @@ class PiTagHydrationError extends Error {
     this.name = "PiTagHydrationError";
   }
 }
-function createPiHydrationPacketConsumer(request, cached = [], byteLimit) {
-  const assembly = createPiTagSnapshotCandidate(cached, byteLimit);
+function createPiHydrationPacketConsumer(request, cached = [], byteLimit, cachedFallback = []) {
+  const assembly = createPiTagSnapshotCandidate(cached, byteLimit, cachedFallback);
   let sequence = 0;
   let generation;
   let busy = false;
@@ -347,7 +347,7 @@ function createPiHydrationPacketConsumer(request, cached = [], byteLimit) {
 function startPiTagSnapshotWorker(request, options = {}) {
   const entry = options.entry ?? new URL(import.meta.url.endsWith(".ts") ? "./tag-snapshot-worker-pi.ts" : "./tag-snapshot-worker-pi.js", import.meta.url);
   const started = performance.now();
-  const consumer = createPiHydrationPacketConsumer(request, options.cached, options.byteLimit);
+  const consumer = createPiHydrationPacketConsumer(request, options.cached, options.byteLimit, options.cachedFallback);
   const worker = inRootAsyncContext2(() => new Worker(entry, { workerData: request }));
   const shutdown = createWorkerShutdown(worker, "pi-tag-snapshot", 1000);
   let exited = false;
@@ -567,11 +567,13 @@ function createPiTagSnapshotReader(db) {
       revisionPresent: total.present
     };
   };
-  const ready = (sessionId) => {
+  const ready = (sessionId, projection) => {
     assertOutsideTransaction();
     const cached = cache.get(sessionId);
     if (!cached?.fallback)
       return false;
+    if (cached.projection !== projection)
+      return false;
     const revision = revisionReaders.get(db)?.(sessionId);
     if (!revision || cached.foreignRevision !== revision[1])
       return false;
@@ -583,17 +585,18 @@ function createPiTagSnapshotReader(db) {
     if (current?.sessionId === sessionId)
       current.cancel();
   };
-  const load = (sessionId, kind) => inSnapshotRoot(async () => {
+  const load = (sessionId, kind, projection) => inSnapshotRoot(async () => {
     if (closed)
       throw new PiTagHydrationError("connection closed");
     managed.add(sessionId);
-    if (ready(sessionId))
+    if (ready(sessionId, projection))
       return;
     if (current) {
       if (current.sessionId === sessionId && !current.retryable && !current.preempted) {
         if (kind === "turn")
           current.kind = "turn";
-        return current.result;
+        if (current.projection === projection)
+          return current.result;
       }
       if (kind === "turn" && current.kind === "prewarm" && current.sessionId !== sessionId && !current.preempted) {
         current.preempted = true;
@@ -603,30 +606,36 @@ function createPiTagSnapshotReader(db) {
       await Promise.allSettled([current.result, current.released]);
       if (epoch !== (sessionEpochs.get(sessionId) ?? 0))
         throw new PiTagHydrationError("session hydration cancelled while queued", "cancelled");
-      return load(sessionId, kind);
+      return load(sessionId, kind, projection);
     }
     if (failedSession === sessionId && performance.now() < failedUntil)
       throw lastFailure;
     watch.run(sessionId);
     const token = stamps(sessionId, ++jobId);
+    const cached = cache.get(sessionId);
+    if (cached && cached.projection !== projection) {
+      cache.delete(sessionId);
+    }
     const previous = cache.get(sessionId);
     const legacyFallbackOnly = previous && previous.foreignRevision === token.foreignRevision && (previous.legacyFallback || token.durableVersion - previous.durableVersion !== token.ownVersion - previous.ownVersion);
     const path = getSqliteDatabasePath2(db);
-    const factory = workerFactories.get(db) ?? ((request, cached) => {
+    const factory = workerFactories.get(db) ?? ((request, cached, cachedFallback) => {
       if (!path)
         throw new PiTagHydrationError("read-only hydration requires a file-backed database");
-      return startPiTagSnapshotWorker({ ...request, path }, { cached });
+      return startPiTagSnapshotWorker({ ...request, path }, { cached, cachedFallback });
     });
     const worker = factory({
       path: path ?? "",
       sessionId,
       connectionEpoch: epoch,
       sessionEpoch: token.sessionEpoch,
-      jobId: token.jobId
-    }, previous?.tags ?? []);
+      jobId: token.jobId,
+      projection
+    }, previous?.tags ?? [], previous?.fallback ?? []);
     const destination = {
       sessionId,
       kind,
+      projection,
       result: Promise.resolve(),
       released: worker.released,
       cancel: worker.cancel
@@ -652,6 +661,7 @@ function createPiTagSnapshotReader(db) {
       if (closed || current !== destination || !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 = {
+        projection,
         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,
@@ -678,15 +688,19 @@ function createPiTagSnapshotReader(db) {
       }
       cache.set(sessionId, snapshot);
     }).catch((error) => {
-      const retryable = error instanceof PiTagHydrationError && (error.code === "stale" || error.code === "cancelled");
+      const releaseCachedAllocations = previous && !legacyFallbackOnly && cache.get(sessionId) === previous && error instanceof PiTagHydrationError && error.message.includes("candidate memory limit exceeded");
+      if (releaseCachedAllocations)
+        cache.delete(sessionId);
+      const failure = releaseCachedAllocations ? new PiTagHydrationError("candidate memory limit exceeded with cached allocations; retrying without cache", "stale") : error;
+      const retryable = failure instanceof PiTagHydrationError && (failure.code === "stale" || failure.code === "cancelled");
       if (retryable)
         destination.retryable = true;
       if (!destination.preempted && current === destination && token.sessionEpoch === (sessionEpochs.get(sessionId) ?? 0)) {
         failedSession = sessionId;
-        lastFailure = error;
+        lastFailure = failure;
         failedUntil = performance.now() + (retryable ? 0 : 500);
       }
-      throw error;
+      throw failure;
     });
     Promise.allSettled([destination.result, worker.released]).then(() => {
       if (current === destination)
@@ -759,7 +773,7 @@ function createPiTagSnapshotReader(db) {
         const replacements = getTagsByNumbers2(db, sessionId, numbers);
         for (const tag of replacements)
           Object.freeze(tag);
-        snapshot.tags = mergeChangedRows(snapshot.tags, dirty, replacements);
+        snapshot.tags = mergeChangedRows(snapshot.tags, dirty, snapshot.projection === "pass" ? replacements.map(projectPiPassTag) : replacements);
         snapshot.active = mergeChangedRows(snapshot.active, dirty, replacements.filter(isActive));
         if (!numbers.every(Number.isSafeInteger)) {
           snapshot.fallback = undefined;
@@ -787,7 +801,16 @@ function createPiTagSnapshotReader(db) {
       throw new PiTagHydrationError("managed snapshot read inside a transaction");
     if (!snapshot)
       return getTagsBySession2(db, sessionId);
-    return borrowed ? snapshot.tags : snapshot.tags.map((tag) => ({ ...tag }));
+    if (snapshot.projection === "pass") {
+      const before = stamps(sessionId, 0);
+      const tags = getTagsBySession2(db, sessionId);
+      const after = stamps(sessionId, 0);
+      if (!samePiTagSnapshotToken(before, after) || before.totalRevision !== after.totalRevision)
+        throw new PiTagHydrationError("full snapshot generation changed", "stale");
+      return borrowed ? tags.map((tag) => Object.freeze(tag)) : tags;
+    }
+    const full = snapshot.tags;
+    return borrowed ? full : full.map((tag) => ({ ...tag }));
   };
   entryReaders.set(db, sync);
   fallbackReaders.set(db, (sessionId) => {
@@ -820,11 +843,28 @@ function createPiTagSnapshotReader(db) {
   });
   return read;
 }
+function projectPiPassTag(tag) {
+  if (tag.status === "active")
+    return tag;
+  return Object.freeze({
+    id: tag.id,
+    tagNumber: tag.tagNumber,
+    messageId: tag.messageId,
+    type: tag.type,
+    status: tag.status,
+    toolOwnerMessageId: tag.toolOwnerMessageId,
+    tokenCount: tag.tokenCount,
+    toolName: tag.toolName,
+    dropMode: tag.dropMode
+  });
+}
 var PI_FALLBACK_ROW_COLUMNS = "id, tag_number, type, message_id, tool_owner_message_id, entry_fingerprint";
 var PI_FALLBACK_ROW_PREDICATE = `((type = 'message' AND message_id LIKE 'pi-msg-%')
 	OR (type = 'tool' AND tool_owner_message_id LIKE 'pi-msg-%'))`;
 var isActive = (tag) => tag.status === "active";
 function sameRow(left, right, keys) {
+  if (Object.keys(left).length !== keys.length)
+    return false;
   for (const key of keys)
     if (!Object.is(left[key], right[key]))
       return false;
@@ -843,11 +883,25 @@ function candidateRowBytes(row, overhead) {
   }
   return bytes;
 }
-function createPiTagSnapshotCandidate(cached = [], byteLimit = 128 * 1024 * 1024) {
+function passTagBytes(row) {
+  return candidateRowBytes(row, 48 + 24 * Object.keys(row).length);
+}
+function createPiTagSnapshotCandidate(cached = [], byteLimit = 128 * 1024 * 1024, cachedFallback = []) {
   const tags = [];
   const active = [];
   const fallback = [];
-  let estimatedBytes = 192;
+  let reusedBytes = 0;
+  for (const row of cached)
+    reusedBytes += passTagBytes(row) + 8 + (isActive(row) ? 8 : 0);
+  if (cached.length)
+    reusedBytes += 128;
+  for (const row of cachedFallback)
+    reusedBytes += candidateRowBytes(row, 192) + 8;
+  if (cachedFallback.length)
+    reusedBytes += 64;
+  let allocatedBytes = 192 + (cachedFallback.length ? 64 + cachedFallback.length * 48 : 0);
+  let estimatedBytes = reusedBytes + allocatedBytes;
+  const fallbackCache = cachedFallback.length && estimatedBytes <= byteLimit ? new Map(cachedFallback.map((row) => [row.id, row])) : undefined;
   let oldIndex = 0;
   let keys;
   let tagsEnded = false;
@@ -857,8 +911,9 @@ function createPiTagSnapshotCandidate(cached = [], byteLimit = 128 * 1024 * 1024
     failed = true;
     throw new Error(`Pi tag hydration: ${reason}`);
   };
-  const admit = (row, overhead) => {
-    estimatedBytes += candidateRowBytes(row, overhead);
+  const admit = (bytes) => {
+    allocatedBytes += bytes;
+    estimatedBytes = reusedBytes + allocatedBytes;
     if (estimatedBytes > byteLimit)
       reject("candidate memory limit exceeded");
   };
@@ -872,8 +927,7 @@ function createPiTagSnapshotCandidate(cached = [], byteLimit = 128 * 1024 * 1024
       const previous = tags.at(-1);
       if (previous && (previous.tagNumber > row.tagNumber || previous.tagNumber === row.tagNumber && (previous.id ?? 0) >= (row.id ?? 0)))
         reject("noncanonical tag order");
-      admit(row, 384);
-      keys ??= Object.keys(row);
+      keys = Object.keys(row);
       while (oldIndex < cached.length) {
         const old = cached[oldIndex];
         if (!old || old.tagNumber > row.tagNumber || old.tagNumber === row.tagNumber && (old.id ?? 0) >= (row.id ?? 0))
@@ -882,6 +936,7 @@ function createPiTagSnapshotCandidate(cached = [], byteLimit = 128 * 1024 * 1024
       }
       const old = cached[oldIndex];
       const selected = old && old.id === row.id && sameRow(old, row, keys) ? old : row;
+      admit((selected === old ? 0 : passTagBytes(row)) + 8 + (isActive(selected) ? 8 : 0));
       Object.freeze(selected);
       tags.push(selected);
       if (isActive(selected))
@@ -890,8 +945,11 @@ function createPiTagSnapshotCandidate(cached = [], byteLimit = 128 * 1024 * 1024
     appendFallback(row) {
       if (failed || fallbackEnded)
         reject("fallback packet after end or failure");
-      admit(row, 192);
-      fallback.push(Object.freeze(row));
+      const old = fallbackCache?.get(row.id);
+      const rowKeys = Object.keys(row);
+      const selected = old && Object.keys(old).length === rowKeys.length && rowKeys.every((key) => Object.is(old[key], row[key])) ? old : row;
+      admit((selected === old ? 0 : candidateRowBytes(row, 192)) + 8);
+      fallback.push(Object.freeze(selected));
     },
     end(stream) {
       if (failed)
@@ -909,7 +967,16 @@ function createPiTagSnapshotCandidate(cached = [], byteLimit = 128 * 1024 * 1024
     finish() {
       if (failed || !tagsEnded || !fallbackEnded)
         throw new Error("Pi tag hydration: incomplete candidate");
-      return { tags, active, fallback, estimatedBytes };
+      if (estimatedBytes > byteLimit)
+        reject("candidate memory limit exceeded");
+      return {
+        tags,
+        active,
+        fallback,
+        estimatedBytes,
+        allocatedBytes,
+        reusedBytes
+      };
     }
   };
 }
@@ -961,15 +1028,24 @@ function mergeChangedRows(rows, dirty, replacements) {
     }
     merged.push(tag);
   }
-  merged.push(...replacements.slice(index));
+  for (;index < replacements.length; index++) {
+    const row = replacements[index];
+    if (row)
+      merged.push(row);
+  }
   return merged;
 }
 var entryReaders = new WeakMap;
 var fallbackReaders = new WeakMap;
 var readers = new WeakMap;
 var revisionReaders = new WeakMap;
-function getPiTagSnapshotView(db, sessionId) {
-  return createPiTagSnapshotReader(db)(sessionId, true);
+function getPiPassTagSnapshotView(db, sessionId) {
+  createPiTagSnapshotReader(db);
+  const snapshot = entryReaders.get(db)?.(sessionId);
+  if (snapshot?.projection === "pass")
+    return snapshot.tags;
+  const full = snapshot?.tags ?? getTagsBySession2(db, sessionId);
+  return full.map(projectPiPassTag);
 }
 function getPiActiveTagSnapshotView(db, sessionId, passTags) {
   createPiTagSnapshotReader(db);
@@ -987,9 +1063,9 @@ var owners = new WeakMap;
 var workerFactories = new WeakMap;
 var activeJobs = new Map;
 var waitDeadlines = new WeakMap;
-function prewarmPiTagSnapshot(db, sessionId) {
+function prewarmPiTagSnapshot(db, sessionId, projection) {
   createPiTagSnapshotReader(db);
-  owners.get(db)?.load(sessionId, "prewarm").catch(() => {});
+  owners.get(db)?.load(sessionId, "prewarm", projection).catch(() => {});
 }
 function cancelPiTagSnapshotSession(sessionId) {
   for (const job of activeJobs.get(sessionId) ?? [])
@@ -1005,17 +1081,17 @@ function assertPiTagSnapshotReady(db, sessionId) {
   createPiTagSnapshotReader(db);
   const owner = owners.get(db);
   owner?.manage(sessionId);
-  if (!owner?.ready(sessionId))
+  if (!owner?.ready(sessionId, "pass") && !owner?.ready(sessionId))
     throw new PiTagHydrationError("tag snapshot is not ready; turn not sent, retry");
 }
-function ensurePiTagSnapshotReady(db, sessionId, budget) {
+function ensurePiTagSnapshotReady(db, sessionId, budget, projection) {
   budget.assert();
   createPiTagSnapshotReader(db);
   const owner = owners.get(db);
   if (!owner)
     throw new PiTagHydrationError("snapshot owner unavailable");
   owner.manage(sessionId);
-  if (owner.ready(sessionId))
+  if (owner.ready(sessionId, projection))
     return;
   let deadline = waitDeadlines.get(budget);
   if (deadline === undefined) {
@@ -1033,7 +1109,7 @@ function ensurePiTagSnapshotReady(db, sessionId, budget) {
       const releaseNativeWaiter = owner.addNativeWaiter(() => budget.remainingOutcome() - PI_CONTEXT_BUDGET.completionReserveMs);
       try {
         await budget.wait(Promise.race([
-          owner.load(sessionId, "turn"),
+          owner.load(sessionId, "turn", projection),
           new Promise((_, reject) => {
             timer = setTimeout(() => reject(new PiTagHydrationError("remaining pass budget exhausted waiting for tag snapshot; turn not sent, retry", "deadline")), allowance);
           })
@@ -1053,4 +1129,4 @@ function ensurePiTagSnapshotReady(db, sessionId, budget) {
   })();
 }
 
-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 };
+export { PI_CONTEXT_BUDGET, PiContextDeadlineError, PiContextSupersededError, PiContextBudget, encodePiHydrationOperation, PiTagHydrationError, projectPiPassTag, PI_FALLBACK_ROW_COLUMNS, PI_FALLBACK_ROW_PREDICATE, getPiPassTagSnapshotView, getPiActiveTagSnapshotView, readPiFallbackTagRows, prewarmPiTagSnapshot, cancelPiTagSnapshotSession, drainPiTagSnapshotSession, assertPiTagSnapshotReady, ensurePiTagSnapshotReady };