@cortexkit/opencode-magic-context 0.49.34 → 0.49.36

package/dist/index-7v05d9b7.js

@@ -0,0 +1,58 @@
+// 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-qgh1qwjj.js → index-850vthn3.js}

@@ -3,11 +3,17 @@ import {
 } from "./index-v0p37hm2.js";
 import {
   log2
-} from "./index-h7tgn49j.js";
+} from "./index-jrfre9ah.js";
 import {
   inRootAsyncContext2,
   getSqliteDatabasePath2
 } from "./index-gzy5w8ya.js";
+import {
+  reuseWorker
+} from "./index-96ztjvkn.js";
+import {
+  createWorkerShutdown
+} from "./index-1d042x6w.js";
 
 // 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-np3rgfw4.js → index-8jjjmhab.js}

@@ -4,13 +4,13 @@ import {
 } from "./index-1zx87sdm.js";
 import {
   estimateTokens
-} from "./index-b88dwwrh.js";
+} from "./index-4xyjr62e.js";
 import {
   getHarness2
 } from "./index-pavzsdc6.js";
 import {
   sessionLog2
-} from "./index-h7tgn49j.js";
+} from "./index-jrfre9ah.js";
 import {
   getTagIdentityWriteGeneration2,
   getSqliteDatabasePath2
@@ -20,7 +20,7 @@ import {
   tagOrderConstraintIndex,
   stableStringify,
   stableStringifyHash
-} from "./index-xrnsygfq.js";
+} from "./index-9wnbnx8f.js";
 import {
   DEFAULT_PROTECTED_TOOLS,
   normalizeProtectedToolName,
@@ -2554,7 +2554,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;
@@ -2564,6 +2566,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))
@@ -2571,8 +2574,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-96ztjvkn.js

@@ -0,0 +1,204 @@
+import {
+  registerExitAbort,
+  unregisterExitAbort
+} from "./index-v0p37hm2.js";
+import {
+  inRootAsyncContext2
+} from "./index-gzy5w8ya.js";
+
+// 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 };