@cortexkit/pi-magic-context 0.49.35 → 0.49.36

package/dist/index-nypgv96r.js

@@ -0,0 +1,58 @@
+// ../plugin/src/shared/reusable-worker-entry.ts
+import { EventEmitter } from "node:events";
+import { parentPort, workerData } from "node:worker_threads";
+function serveWorkerJobs(run, autoClose = true) {
+  if (!parentPort)
+    throw new Error("worker requires a parent port");
+  const parent = parentPort;
+  if (!workerData?.reusableWorker) {
+    Promise.resolve(run(workerData, parent)).catch(rethrow);
+    return;
+  }
+  let active;
+  parent.on("message", (message) => {
+    if (!("start" in message)) {
+      if (active?.id === message.jobId)
+        active.port.emit("message", message.value);
+      return;
+    }
+    if (active)
+      throw new Error("reusable worker received overlapping jobs");
+    const id = message.jobId;
+    let closed = false;
+    const port = Object.assign(new EventEmitter, {
+      postMessage(value, transferList) {
+        if (!closed)
+          parent.postMessage({ jobId: id, value }, transferList);
+      },
+      close() {
+        if (closed)
+          return;
+        closed = true;
+        port.removeAllListeners();
+        active = undefined;
+        parent.postMessage({
+          jobId: id,
+          finished: true,
+          code: Number(process.exitCode) || 0
+        });
+      }
+    });
+    active = { id, port };
+    try {
+      Promise.resolve(run(message.start, port)).then(() => {
+        if (autoClose)
+          port.close();
+      }).catch(rethrow);
+    } catch (error) {
+      rethrow(error);
+    }
+  });
+}
+function rethrow(error) {
+  setTimeout(() => {
+    throw error;
+  });
+}
+
+export { serveWorkerJobs };

package/dist/{index-d21rhpbd.js → index-p9jfa33t.js}

@@ -39,12 +39,12 @@ import {
   expandToolPart,
   visitRawSessionMessages2,
   readRawSessionMessageById2
-} from "./index-svqk0701.js";
+} from "./index-mx757f3g.js";
 import {
   isRecord,
   providerVisibleMessage,
   getTagById2
-} from "./index-yhsmjvqa.js";
+} from "./index-pwp6zyx3.js";
 import {
   estimateTokens
 } from "./index-wt7vmyj4.js";
@@ -64,17 +64,17 @@ import {
 import {
   isPidAlive,
   readProcessStartTime
-} from "./index-11knwv2h.js";
+} from "./index-a7sj2bam.js";
 import {
   gaDatabasePath2,
   V2StoreReader2
 } from "./index-ea37qn4x.js";
 import {
   deleteUnmappedMessageFtsRows2
-} from "./index-rgvqh5x7.js";
+} from "./index-ck8wj35v.js";
 import {
   deleteChunkEmbedBackoffForSession2
-} from "./index-2p691ayw.js";
+} from "./index-f9qet7y8.js";
 import {
   invalidateAutoEmbedSession,
   drainBackgroundBatches

package/dist/{index-yhsmjvqa.js → index-pwp6zyx3.js}

@@ -2178,7 +2178,9 @@ function getAllStatusTagTokenTotalsFlat2(db, sessionId, floor = 0, calibration =
                        FROM tags
                        WHERE session_id = ?`).all(sessionId);
   const totals = new Map;
+  const summaryRemovedTotals = new Map;
   const nullMessageIds = new Set;
+  const nullSummaryRemovedMessageIds = new Set;
   for (const row of rows) {
     if (row.type === "tool" && row.tool_owner_message_id === null)
       continue;
@@ -2188,6 +2190,7 @@ function getAllStatusTagTokenTotalsFlat2(db, sessionId, floor = 0, calibration =
     if (row.token_count === null) {
       nullMessageIds.add(owner);
       totals.delete(owner);
+      summaryRemovedTotals.delete(owner);
       continue;
     }
     if (nullMessageIds.has(owner))
@@ -2195,8 +2198,16 @@ function getAllStatusTagTokenTotalsFlat2(db, sessionId, floor = 0, calibration =
     const ratio = row.type === "tool" ? calibration.toolsRatio : calibration.proseRatio;
     const weight = ((row.token_count ?? 0) + (row.input_token_count ?? 0)) * ratio + (row.reasoning_token_count ?? 0) * calibration.proseRatio;
     totals.set(owner, (totals.get(owner) ?? 0) + weight);
+    if (row.type === "tool" && row.input_token_count === null) {
+      nullSummaryRemovedMessageIds.add(owner);
+      summaryRemovedTotals.delete(owner);
+    }
+    if (!nullSummaryRemovedMessageIds.has(owner)) {
+      const removedWeight = row.type === "tool" ? (row.input_token_count ?? 0) * calibration.toolsRatio : row.type === "message" ? row.token_count * calibration.proseRatio : 0;
+      summaryRemovedTotals.set(owner, (summaryRemovedTotals.get(owner) ?? 0) + removedWeight);
+    }
   }
-  return { totals, nullMessageIds };
+  return { totals, summaryRemovedTotals, nullMessageIds };
 }
 function getReasoningTokenEstimatesByMessage2(db, sessionId, proseRatio) {
   const summary = readTagOwnerSummary(db, sessionId, proseRatio);

package/dist/{index-m68qfjte.js → index-ry84c8dr.js}

@@ -6,7 +6,7 @@ import {
 } from "./index-wt7vmyj4.js";
 import {
   readRawSessionMessageIdOrdinalsForRange2
-} from "./index-svqk0701.js";
+} from "./index-mx757f3g.js";
 
 // ../plugin/src/tools/ctx-expand/search-archive.ts
 var archiveReadsOnThisThread = 0;

package/dist/index-wfqysrwq.js

@@ -0,0 +1,204 @@
+import {
+  registerExitAbort,
+  unregisterExitAbort
+} from "./index-8sqebjzk.js";
+import {
+  inRootAsyncContext2
+} from "./index-2qtx0q6h.js";
+
+// ../plugin/src/shared/reusable-worker.ts
+import { EventEmitter } from "node:events";
+import * as timers from "node:timers";
+import {
+  MessageChannel,
+  receiveMessageOnPort,
+  Worker
+} from "node:worker_threads";
+var pools = new Map;
+var liveSlots = new Set;
+var nextId = 0;
+var IDLE_MS = 60000;
+var sharedCloneWorks = (() => {
+  const source = new SharedArrayBuffer(1);
+  const clone = structuredClone(source);
+  new Uint8Array(source)[0] = 1;
+  return new Uint8Array(clone)[0] === 1;
+})();
+var cloneChannel;
+function cloneJobValue(value, transferList) {
+  if (sharedCloneWorks)
+    return structuredClone(value, { transfer: transferList });
+  if (!cloneChannel) {
+    cloneChannel = inRootAsyncContext2(() => new MessageChannel);
+    cloneChannel.port1.unref();
+    cloneChannel.port2.unref();
+  }
+  cloneChannel.port1.postMessage(value, transferList);
+  const packet = receiveMessageOnPort(cloneChannel.port2);
+  if (!packet)
+    throw new Error("worker input clone did not arrive synchronously");
+  return packet.message;
+}
+
+class Lease extends EventEmitter {
+  slot;
+  data;
+  id = ++nextId;
+  ended = false;
+  referenced = true;
+  outbox = [];
+  constructor(slot, data) {
+    super();
+    this.slot = slot;
+    this.data = data;
+  }
+  postMessage(value, transferList) {
+    if (this.ended)
+      return;
+    if (this.slot.active === this)
+      this.slot.worker.postMessage({ jobId: this.id, value }, transferList);
+    else
+      this.outbox.push(cloneJobValue({ value, transferList }, transferList));
+  }
+  start() {
+    if (this.referenced)
+      this.slot.worker.ref();
+    else
+      this.slot.worker.unref();
+    this.emit("online");
+    this.slot.worker.postMessage({ jobId: this.id, start: this.data });
+    for (const { value, transferList } of this.outbox.splice(0))
+      this.postMessage(value, transferList);
+  }
+  ref() {
+    this.referenced = true;
+    if (this.slot.active === this)
+      this.slot.worker.ref();
+    return this;
+  }
+  unref() {
+    this.referenced = false;
+    if (this.slot.active === this)
+      this.slot.worker.unref();
+    return this;
+  }
+  async terminate() {
+    if (this.ended)
+      return 0;
+    if (this.slot.active === this)
+      return await this.slot.worker.terminate();
+    this.ended = true;
+    this.slot.queue.splice(this.slot.queue.indexOf(this), 1);
+    this.emit("exit", 0);
+    return 0;
+  }
+}
+function reuseWorker(entry, options, idleMs = IDLE_MS) {
+  const data = cloneJobValue(options.workerData);
+  const slot = acquireSlot(entry, options, idleMs);
+  const lease = new Lease(slot, data);
+  enqueue(slot, lease);
+  return lease;
+}
+function enqueue(slot, lease) {
+  timers.clearTimeout(slot.idle);
+  lease.slot = slot;
+  slot.queue.push(lease);
+  queueMicrotask(() => slot.advance());
+}
+function acquireSlot(entry, options, idleMs) {
+  const data = options.workerData;
+  const key = JSON.stringify([
+    String(entry),
+    data?.path ?? data?.dbPath,
+    data?.harness,
+    data?.job
+  ]);
+  let slot = pools.get(key);
+  if (!slot) {
+    const worker = inRootAsyncContext2(() => new Worker(entry, { ...options, workerData: { reusableWorker: true } }));
+    const controller = new AbortController;
+    slot = { worker, controller, queue: [], advance: () => {} };
+    pools.set(key, slot);
+    liveSlots.add(slot);
+    const owned = slot;
+    const advance = () => {
+      if (controller.signal.aborted || owned.active)
+        return;
+      timers.clearTimeout(owned.idle);
+      const lease = owned.queue.shift();
+      owned.active = lease;
+      if (!lease) {
+        worker.unref();
+        owned.idle = timers.setTimeout(() => {
+          if (pools.get(key) === owned)
+            pools.delete(key);
+          worker.terminate();
+        }, idleMs);
+        owned.idle.unref();
+        return;
+      }
+      lease.start();
+    };
+    owned.advance = advance;
+    worker.on("message", (message) => {
+      const lease = owned.active;
+      if (!lease || message.jobId !== lease.id)
+        return;
+      if (!message.finished) {
+        lease.emit("message", message.value);
+        return;
+      }
+      lease.ended = true;
+      owned.active = undefined;
+      if (message.code) {
+        if (pools.get(key) === owned)
+          pools.delete(key);
+        lease.emit("exit", message.code);
+        worker.terminate();
+        return;
+      }
+      lease.emit("exit", 0);
+      advance();
+    });
+    worker.on("error", (error) => {
+      if (pools.get(key) === owned)
+        pools.delete(key);
+      owned.active?.emit("error", error);
+    });
+    worker.on("exit", (code) => {
+      liveSlots.delete(owned);
+      timers.clearTimeout(owned.idle);
+      if (pools.get(key) === owned)
+        pools.delete(key);
+      const active = owned.active;
+      owned.active = undefined;
+      if (active && !active.ended) {
+        active.ended = true;
+        active.emit("exit", code);
+      }
+      for (const lease of owned.queue.splice(0)) {
+        if (controller.signal.aborted) {
+          lease.ended = true;
+          lease.emit("exit", code);
+        } else {
+          try {
+            enqueue(acquireSlot(entry, options, idleMs), lease);
+          } catch (error) {
+            lease.ended = true;
+            lease.emit("error", error);
+            lease.emit("exit", 1);
+          }
+        }
+      }
+    });
+    controller.signal.addEventListener("abort", () => {
+      worker.terminate();
+    }, { once: true });
+    registerExitAbort(controller);
+    worker.once("exit", () => unregisterExitAbort(controller));
+  }
+  return slot;
+}
+
+export { reuseWorker };

package/dist/{index-0rvn6vhq.js → index-wwsfevck.js}

@@ -7,7 +7,7 @@ import {
 import {
   getTagsBySession2,
   getTagsByNumbers2
-} from "./index-yhsmjvqa.js";
+} from "./index-pwp6zyx3.js";
 import {
   inRootAsyncContext2,
   getSqliteDatabasePath2,
@@ -16,9 +16,12 @@ import {
 import {
   createFailClosedBlockingError
 } from "./index-3bb24eb6.js";
+import {
+  reuseWorker
+} from "./index-wfqysrwq.js";
 import {
   createWorkerShutdown
-} from "./index-54wmg4rj.js";
+} from "./index-x2n261wp.js";
 
 // src/pi-context-budget.ts
 var PI_CONTEXT_BUDGET = {
@@ -348,7 +351,7 @@ 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, options.cachedFallback);
-  const worker = inRootAsyncContext2(() => new Worker(entry, { workerData: request }));
+  const worker = inRootAsyncContext2(() => options.entry ? new Worker(entry, { workerData: request }) : reuseWorker(entry, { workerData: request }));
   const shutdown = createWorkerShutdown(worker, "pi-tag-snapshot", 1000);
   let exited = false;
   let settled = false;

package/dist/{index-54wmg4rj.js → index-x2n261wp.js}

@@ -3,31 +3,33 @@ var WORKER_CLOSE_MESSAGE = { kind: "close" };
 function isWorkerCloseMessage(message) {
   return typeof message === "object" && message !== null && message.kind === WORKER_CLOSE_MESSAGE.kind;
 }
-function exitOnWorkerClose(port, closeConnections) {
+function exitOnWorkerClose(port, closeConnections, exitThread = true) {
   const listener = (message) => {
     if (!isWorkerCloseMessage(message))
       return;
     try {
       closeConnections();
     } finally {
-      process.exit(0);
+      if (exitThread)
+        process.exit(0);
+      closePort();
     }
   };
   if (!port)
     return { closePort() {} };
-  port.on("message", listener);
+  const owner = port;
+  owner.on("message", listener);
   let closed = false;
-  return {
-    closePort() {
-      if (closed)
-        return;
-      closed = true;
-      setTimeout(() => {
-        port.off("message", listener);
-        port.close();
-      });
-    }
-  };
+  function closePort() {
+    if (closed)
+      return;
+    closed = true;
+    setTimeout(() => {
+      owner.off("message", listener);
+      owner.close();
+    });
+  }
+  return { closePort };
 }
 var outcomes = new Map;
 function createWorkerShutdown(worker, site, deadlineMs) {

package/dist/{index-d0w84hy5.js → index-y90fxz4t.js}

@@ -1,6 +1,6 @@
 import {
   registerExitAbort
-} from "./index-399p688g.js";
+} from "./index-8sqebjzk.js";
 import {
   log2
 } from "./index-gymgz20n.js";
@@ -8,6 +8,12 @@ import {
   inRootAsyncContext2,
   getSqliteDatabasePath2
 } from "./index-2qtx0q6h.js";
+import {
+  reuseWorker
+} from "./index-wfqysrwq.js";
+import {
+  createWorkerShutdown
+} from "./index-x2n261wp.js";
 
 // ../plugin/src/features/magic-context/compaction-marker-candidates.ts
 import { existsSync, realpathSync } from "node:fs";
@@ -140,7 +146,7 @@ function runCandidateWorker(path, sessionId, options) {
         return;
       }
       workers.delete(worker);
-      const stopped = worker.terminate();
+      const stopped = snapshot ? createWorkerShutdown(worker, "marker-candidates", 1000).close() : worker.terminate();
       worker.unref();
       stopped.then(() => resolve(snapshot), () => resolve(snapshot));
     };
@@ -153,7 +159,7 @@ function runCandidateWorker(path, sessionId, options) {
       timer.unref?.();
     };
     try {
-      worker = inRootAsyncContext2(() => new Worker(entry, { workerData: { path, sessionId } }));
+      worker = inRootAsyncContext2(() => options.entry ? new Worker(entry, { workerData: { path, sessionId } }) : reuseWorker(entry, { workerData: { path, sessionId } }));
       workers.add(worker);
       worker.unref();
       deadline(options.acceptMs ?? 2000);

package/dist/{index-a11nmw5t.js → index-z7dktknj.js}

@@ -20,9 +20,12 @@ import {
   inRootAsyncContext2,
   getSqliteDatabasePath2
 } from "./index-2qtx0q6h.js";
+import {
+  reuseWorker
+} from "./index-wfqysrwq.js";
 import {
   createWorkerShutdown
-} from "./index-54wmg4rj.js";
+} from "./index-x2n261wp.js";
 import {
   DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS2,
   CHUNK_WINDOW_SAFETY_RATIO2,
@@ -40,7 +43,7 @@ import {
   countSessionCompartmentEmbedCoverage2,
   countSessionCompartmentEmbedCoveragePolite2,
   countUnembeddedSessionCompartmentsPolite2
-} from "./index-2p691ayw.js";
+} from "./index-f9qet7y8.js";
 import {
   DEFAULT_LOCAL_EMBEDDING_MODEL
 } from "./index-ccanzg8p.js";
@@ -611,7 +614,6 @@ class OpenAICompatibleEmbeddingProvider {
 import { createHash as createHash2, randomUUID } from "node:crypto";
 
 // ../plugin/src/features/magic-context/chunk-embedding-writer.ts
-import { Worker } from "node:worker_threads";
 function createChunkEmbeddingWriter(db) {
   const path = getSqliteDatabasePath2(db);
   if (!path)
@@ -620,7 +622,7 @@ function createChunkEmbeddingWriter(db) {
     throw new Error("chunk embedding writer requires a filesystem path");
   const entry = new URL(import.meta.url.endsWith(".ts") ? "./chunk-embedding-write-worker.ts" : "./chunk-embedding-write-worker.js", import.meta.url);
   const timeout = db.prepare("PRAGMA busy_timeout").get().timeout;
-  const worker = inRootAsyncContext2(() => new Worker(entry, { workerData: { path, harness: getHarness2(), timeout } }));
+  const worker = inRootAsyncContext2(() => reuseWorker(entry, { workerData: { path, harness: getHarness2(), timeout } }));
   const shutdown = createWorkerShutdown(worker, "chunk-embedding-writer", timeout + 2000);
   let pending;
   let failure;