@cortexkit/opencode-magic-context 0.49.34 → 0.49.36

package/dist/index-prw8apnc.js

@@ -0,0 +1,194 @@
+import {
+  registerExitAbort
+} from "./index-v0p37hm2.js";
+import {
+  inRootAsyncContext2
+} from "./index-gzy5w8ya.js";
+import {
+  createWorkerShutdown
+} from "./index-1d042x6w.js";
+
+// src/tools/ctx-expand/v2-archive-reader.ts
+import { Worker } from "node:worker_threads";
+var worker;
+var shutdown;
+var ready;
+var idle;
+var startingTimer;
+var rejectStart;
+var nextId = 0;
+var exitRegistered = false;
+var pending = new Map;
+async function stopV2ArchiveReader() {
+  const closing = shutdown;
+  worker = undefined;
+  shutdown = undefined;
+  ready = undefined;
+  clearTimeout(idle);
+  clearTimeout(startingTimer);
+  rejectStart?.(new Error("Search archive worker unavailable: reader stopped"));
+  rejectStart = undefined;
+  for (const item of pending.values()) {
+    clearTimeout(item.timer);
+    item.reject(new Error("Search archive worker unavailable: reader stopped"));
+  }
+  pending.clear();
+  await closing?.close();
+}
+function start() {
+  if (ready)
+    return ready;
+  if (!exitRegistered) {
+    exitRegistered = true;
+    const controller = new AbortController;
+    controller.signal.addEventListener("abort", () => {
+      stopV2ArchiveReader();
+    }, { once: true });
+    registerExitAbort(controller);
+  }
+  ready = new Promise((resolve, reject) => {
+    rejectStart = reject;
+    const entry = new URL(import.meta.url.endsWith(".ts") ? "../../hooks/magic-context/raw-ordinal-warmup-worker.ts" : "./raw-ordinal-warmup-worker.js", import.meta.url);
+    const current = inRootAsyncContext2(() => new Worker(entry, { workerData: { v2ArchiveReader: true } }));
+    worker = current;
+    shutdown = createWorkerShutdown(current, "v2-archive-reader", 2000);
+    current.unref();
+    const fail = (detail) => {
+      if (worker !== current)
+        return;
+      clearTimeout(startingTimer);
+      reject(new Error(`Search archive worker unavailable: ${detail}`));
+      stopV2ArchiveReader();
+    };
+    startingTimer = setTimeout(() => fail("reader did not start"), 1e4);
+    startingTimer.unref?.();
+    current.on("error", (error) => fail(String(error)));
+    current.on("exit", (code) => fail(`exit code ${code}`));
+    current.on("message", (reply) => {
+      if (worker !== current)
+        return;
+      if (reply.kind === "v2-archive-ready") {
+        clearTimeout(startingTimer);
+        rejectStart = undefined;
+        resolve();
+      } else if (reply.kind === "v2-archive-result") {
+        const item = pending.get(reply.id);
+        if (!item)
+          return;
+        pending.delete(reply.id);
+        clearTimeout(item.timer);
+        if (reply.error)
+          item.reject(new Error(`Search archive worker unavailable: ${reply.error}`));
+        else
+          item.resolve(reply.text);
+        if (pending.size === 0) {
+          idle = setTimeout(() => {
+            stopV2ArchiveReader();
+          }, 60000);
+          idle.unref?.();
+        }
+      }
+    });
+  });
+  return ready;
+}
+async function readV2ArchiveOffThread2(path, rawPath, sessionId, read) {
+  try {
+    clearTimeout(idle);
+    await start();
+    const current = worker;
+    if (!current)
+      throw new Error("Search archive worker unavailable: reader stopped");
+    return await new Promise((resolve, reject) => {
+      const id = ++nextId;
+      const timer = setTimeout(() => {
+        stopV2ArchiveReader();
+      }, 10 * 60000);
+      timer.unref?.();
+      pending.set(id, { resolve, reject, timer });
+      try {
+        current.postMessage({
+          kind: "v2-archive-read",
+          id,
+          path,
+          rawPath,
+          sessionId,
+          read
+        });
+      } catch {
+        stopV2ArchiveReader();
+      }
+    });
+  } catch (error) {
+    await stopV2ArchiveReader();
+    if (error instanceof Error && error.message.startsWith("Search archive worker unavailable:"))
+      throw error;
+    throw new Error(`Search archive worker unavailable: ${String(error)}`);
+  }
+}
+async function serveV2ArchiveReads2(port, openConnections) {
+  const [
+    { Database },
+    { V2StoreReaderPool },
+    { createV2RawMessageReader, createV2RawMessageProvider },
+    { setBoundedRawMessageProvider },
+    { renderItemByTag, renderMessageByOrdinal, renderVerboseRangeForTool },
+    { renderSearchArchive },
+    { createV2RecoveryAttachments }
+  ] = await Promise.all([
+    import("./sqlite-zdgm52sv.js"),
+    import("./store-reader-yh19h38c.js"),
+    import("./store-s3eykdjt.js"),
+    import("./read-session-chunk-26yrrhyz.js"),
+    import("./render-h1qarr8a.js"),
+    import("./search-archive-q79hyqxs.js"),
+    import("./expand-attachments-h33jbgyz.js")
+  ]);
+  const pool = new V2StoreReaderPool;
+  openConnections.add(pool);
+  port.on("message", (request) => {
+    if (request.kind !== "v2-archive-read")
+      return;
+    let db;
+    let unregister;
+    let rawReader;
+    let reply;
+    try {
+      db = new Database(request.path, { readonly: true, fileMustExist: true });
+      openConnections.add(db);
+      db.exec("PRAGMA busy_timeout = 250");
+      const raw = pool.open(request.rawPath);
+      rawReader = raw;
+      const reader = createV2RawMessageReader(() => raw, undefined, () => {});
+      const attachments = createV2RecoveryAttachments(raw);
+      unregister = setBoundedRawMessageProvider(request.sessionId, createV2RawMessageProvider(reader, request.sessionId));
+      const read = request.read;
+      let text;
+      if (read.kind === "tag") {
+        text = renderItemByTag(db, request.sessionId, read.tag, "part", attachments);
+      } else {
+        const start = read.kind === "message" ? read.message : read.start;
+        const end = read.kind === "message" ? read.message : read.end;
+        text = renderSearchArchive(db, request.sessionId, start, end, read.tokenBudget, read.kind === "archive" && read.archiveOnly, () => reader.ordinalMapForRange(request.sessionId, start, end));
+        if (text === null && read.kind === "message") {
+          text = renderMessageByOrdinal(request.sessionId, read.message, attachments);
+        } else if (text === null && read.kind === "verbose") {
+          text = renderVerboseRangeForTool(request.sessionId, start, end, read.tokenBudget, read.expandTools, attachments);
+        }
+      }
+      reply = { kind: "v2-archive-result", id: request.id, text };
+    } catch (error) {
+      reply = { kind: "v2-archive-result", id: request.id, text: null, error: String(error) };
+    } finally {
+      unregister?.();
+      rawReader?.close();
+      if (db)
+        openConnections.delete(db);
+      db?.close();
+    }
+    port.postMessage(reply);
+  });
+  port.postMessage({ kind: "v2-archive-ready" });
+}
+
+export { readV2ArchiveOffThread2, serveV2ArchiveReads2 };

package/dist/{index-rverk2vz.js → index-r2epb000.js}

@@ -3,15 +3,18 @@ import {
 } from "./index-v0p37hm2.js";
 import {
   log2
-} from "./index-h7tgn49j.js";
+} from "./index-jrfre9ah.js";
 import {
   inRootAsyncContext2,
   getSqliteDatabasePath2,
   releaseIndexOwner2
 } from "./index-gzy5w8ya.js";
+import {
+  reuseWorker
+} from "./index-96ztjvkn.js";
 import {
   createWorkerShutdown
-} from "./index-cpjk5jd2.js";
+} from "./index-1d042x6w.js";
 
 // src/hooks/magic-context/raw-ordinal-warmup.ts
 import { Worker } from "node:worker_threads";
@@ -1207,6 +1210,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();
@@ -1224,6 +1228,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();
@@ -1231,8 +1239,14 @@ function runSessionWarmupWorker(input, options) {
     }
     options.signal?.addEventListener("abort", abort, { once: true });
     try {
-      worker = inRootAsyncContext2(() => new Worker(options.entry ?? defaultEntry(), {
+      worker = inRootAsyncContext2(() => options.entry ? new Worker(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) {
@@ -1241,7 +1255,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);
@@ -1271,6 +1288,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 (isRawSessionSummaryWarm2(db, sessionId))
     return Promise.resolve("warm");