@cortexkit/magic-context 0.49.35 → 0.49.37

package/dist/index.js

@@ -27078,11 +27078,210 @@ function registerExitAbort(controller) {
   listenerRegistered = true;
   process.once("exit", abortAll);
 }
+function unregisterExitAbort(controller) {
+  controllers.delete(controller);
+}
 var controllers, listenerRegistered = false;
 var init_exit_abort_registry = __esm(() => {
   controllers = new Set;
 });
 
+// ../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";
+function cloneJobValue(value, transferList) {
+  if (sharedCloneWorks)
+    return structuredClone(value, { transfer: transferList });
+  if (!cloneChannel) {
+    cloneChannel = inRootAsyncContext(() => 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;
+}
+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 = inRootAsyncContext(() => 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;
+}
+var pools, liveSlots, nextId = 0, IDLE_MS = 60000, sharedCloneWorks, cloneChannel, Lease;
+var init_reusable_worker = __esm(async () => {
+  init_exit_abort_registry();
+  await init_sqlite();
+  pools = new Map;
+  liveSlots = new Set;
+  sharedCloneWorks = (() => {
+    const source = new SharedArrayBuffer(1);
+    const clone = structuredClone(source);
+    new Uint8Array(source)[0] = 1;
+    return new Uint8Array(clone)[0] === 1;
+  })();
+  Lease = 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;
+    }
+  };
+});
+
 // ../plugin/src/shared/worker-shutdown.ts
 function createWorkerShutdown(worker, site, deadlineMs) {
   let exited = false;
@@ -28177,7 +28376,7 @@ END`;
 });
 
 // ../plugin/src/hooks/magic-context/raw-ordinal-warmup.ts
-import { Worker } from "node:worker_threads";
+import { Worker as Worker2 } from "node:worker_threads";
 function stopRawSessionOrdinalWarmups() {
   for (const stop of [...activeWorkers.values()])
     stop("stopped");
@@ -28209,6 +28408,7 @@ function runSessionWarmupWorker(input, options) {
       clearTimeout(deadline);
       options.signal?.removeEventListener("abort", abort);
       if (worker) {
+        worker.off("online", startDeadline);
         activeWorkers.delete(worker);
         const stopped = shutdown?.close() ?? worker.terminate();
         worker.unref();
@@ -28226,6 +28426,10 @@ function runSessionWarmupWorker(input, options) {
       deadline = setTimeout(() => finish({ failure, detail: `no reply within ${ms} ms` }), ms);
       deadline.unref?.();
     };
+    const startDeadline = () => {
+      if (!settled)
+        arm("not-accepted", options.acceptMs ?? ACCEPT_TIMEOUT_MS);
+    };
     const abort = () => finish({ failure: "stopped", detail: "stopped" });
     if (options.signal?.aborted) {
       abort();
@@ -28233,8 +28437,14 @@ function runSessionWarmupWorker(input, options) {
     }
     options.signal?.addEventListener("abort", abort, { once: true });
     try {
-      worker = inRootAsyncContext(() => new Worker(options.entry ?? defaultEntry(), {
+      worker = inRootAsyncContext(() => options.entry ? new Worker2(options.entry, {
         workerData: { ...input, openCancellation: openCancellation.buffer }
+      }) : reuseWorker(defaultEntry(), {
+        workerData: {
+          ...input,
+          job: rawWorkerJobKind(input),
+          openCancellation: openCancellation.buffer
+        }
       }));
       shutdown = createWorkerShutdown(worker, "raw-ordinal-warmup", WARMUP_CLOSE_DEADLINE_MS);
     } catch (error) {
@@ -28243,7 +28453,10 @@ function runSessionWarmupWorker(input, options) {
     }
     worker.unref();
     activeWorkers.set(worker, (failure) => finish({ failure, detail: "stopped" }));
-    arm("not-accepted", options.acceptMs ?? ACCEPT_TIMEOUT_MS);
+    if (options.entry)
+      startDeadline();
+    else
+      worker.once("online", startDeadline);
     worker.on("message", (reply) => {
       if (reply.kind === "accepted")
         arm("no-result", options.resultMs ?? RESULT_TIMEOUT_MS);
@@ -28273,6 +28486,19 @@ function runSessionWarmupWorker(input, options) {
     worker.on("exit", (code) => finish({ failure: "exited", detail: `exit code ${code}` }));
   });
 }
+function rawWorkerJobKind(input) {
+  if (input.indexMessage)
+    return "index-message";
+  if (input.ftsRowidBackfill)
+    return "fts-rowid-backfill";
+  if (input.searchArchive)
+    return "search-archive";
+  if (input.exactOrdinalIds)
+    return "exact-ordinal-ids";
+  if (input.tagRatio !== undefined)
+    return input.tagState ? "tag-delta" : "tag-summary";
+  return "ordinal-scan";
+}
 function prewarmRawSessionOrdinalsForDb(db, sessionId, options = {}) {
   if (isRawSessionSummaryWarm(db, sessionId))
     return Promise.resolve("warm");
@@ -28335,6 +28561,7 @@ var init_raw_ordinal_warmup = __esm(async () => {
   init_logger();
   init_worker_shutdown();
   await __promiseAll([
+    init_reusable_worker(),
     init_sqlite(),
     init_read_session_raw(),
     init_sqlite()
@@ -28934,7 +29161,10 @@ var init_off_thread_migration_clock = () => {};
 var init_migration_worker_client = __esm(async () => {
   init_logger();
   init_off_thread_migration_clock();
-  await init_sqlite();
+  await __promiseAll([
+    init_reusable_worker(),
+    init_sqlite()
+  ]);
 });
 
 // ../plugin/src/features/magic-context/memory/constants.ts

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cortexkit/magic-context",
-    "version": "0.49.35",
+    "version": "0.49.37",
     "description": "Unified CLI for Magic Context — setup, doctor, and migration across OpenCode, Pi, and OMP",
     "keywords": [
         "opencode",