@remnic/core 9.6.28 → 9.6.29

package/dist/{chunk-4273YO6I.js → chunk-5WJ4LBFR.js}

@@ -323,7 +323,7 @@ import {
   createCorrectionService,
   detectPassiveCorrections,
   qmdCollectionPathParts
-} from "./chunk-YDF4HL3W.js";
+} from "./chunk-5BHIGBHQ.js";
 import {
   importCapsule
 } from "./chunk-M5QKGHCR.js";
@@ -15511,6 +15511,61 @@ async function drainRecallWrites(owner) {
   }
 }
 
+// src/orchestration/xray-capture-queue.ts
+var XrayCaptureQueue = class {
+  tail = Promise.resolve();
+  async run(operation, state, signal) {
+    throwIfAborted(signal, "x-ray capture aborted before queueing");
+    const previous = this.tail;
+    let release = () => {
+    };
+    this.tail = new Promise((resolve) => {
+      release = resolve;
+    });
+    try {
+      await this.waitForTurn(previous, signal);
+    } catch (error) {
+      void previous.then(release, release);
+      throw error;
+    }
+    let previousSnapshot = null;
+    let didReadPreviousSnapshot = false;
+    try {
+      previousSnapshot = state.read();
+      didReadPreviousSnapshot = true;
+      const recallStartedAt = Date.now();
+      state.clear();
+      const result = await operation();
+      const snapshot = state.read();
+      if (!snapshot) state.restore(previousSnapshot);
+      return { result, snapshot, recallStartedAt };
+    } catch (error) {
+      if (didReadPreviousSnapshot) state.restore(previousSnapshot);
+      throw error;
+    } finally {
+      release();
+    }
+  }
+  async waitForTurn(previous, signal) {
+    throwIfAborted(signal, "x-ray capture aborted while queued");
+    if (!signal) {
+      await previous;
+      return;
+    }
+    let onAbort;
+    const aborted = new Promise((_resolve, reject) => {
+      onAbort = () => reject(abortError("x-ray capture aborted while queued"));
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+    try {
+      await Promise.race([previous, aborted]);
+      throwIfAborted(signal, "x-ray capture aborted while queued");
+    } finally {
+      if (onAbort) signal.removeEventListener("abort", onAbort);
+    }
+  }
+};
+
 // src/orchestrator.ts
 var Orchestrator = class {
   storage;
@@ -15592,6 +15647,8 @@ var Orchestrator = class {
    * capturing caller can still read their snapshot back.
    */
   lastXraySnapshot = null;
+  /** Per-instance ordering domain for every writer of `lastXraySnapshot`. */
+  xrayCaptureQueue = new XrayCaptureQueue();
   embeddingFallback;
   conversationIndexDir;
   extraction;
@@ -16751,7 +16808,7 @@ ${doc.content}` : doc.content,
   async validateLocalLlmModel() {
     return this.workspaceOpsCoordinator.validateLocalLlmModel();
   }
-  async recall(prompt, sessionKey, options = {}) {
+  invokeRecall(prompt, sessionKey, options = {}) {
     return (this.recallEntryCoordinator ?? new RecallEntryCoordinator(
       selfDeps(this)
     )).recall(
@@ -16760,21 +16817,64 @@ ${doc.content}` : doc.content,
       options
     );
   }
+  async recall(prompt, sessionKey, options = {}) {
+    if (options.xrayCapture === true) {
+      const { result } = await this.runRecallWithXrayCapture(
+        prompt,
+        sessionKey,
+        options
+      );
+      return result;
+    }
+    return this.invokeRecall(prompt, sessionKey, options);
+  }
   /**
-   * Return the most recent X-ray snapshot captured during a
-   * `recall()` call that passed `xrayCapture: true` (issue #570 PR 1).
+   * Return the most recent X-ray snapshot captured during a recall.
    * Returns `null` when no such capture has occurred on this
    * orchestrator instance.  Returned snapshot is a deep copy so
    * caller mutation cannot tear the stored value.
+   *
+   * @deprecated Reading this after a separate `recall()` is not atomic. Use
+   * `recallWithXrayCapture()` when the snapshot must belong to that call.
    */
   getLastXraySnapshot() {
     if (!this.lastXraySnapshot) return null;
     return structuredClone(this.lastXraySnapshot);
   }
-  /** Clear the captured X-ray snapshot.  Exposed for tests / explicit reset. */
+  /**
+   * Clear the captured X-ray snapshot. Exposed for tests / explicit reset.
+   *
+   * @deprecated A separate clear → recall → get sequence is not atomic. Use
+   * `recallWithXrayCapture()` for capture operations.
+   */
   clearLastXraySnapshot() {
     this.lastXraySnapshot = null;
   }
+  /** Atomically run recall and return the cloned X-ray snapshot it published. */
+  async recallWithXrayCapture(prompt, sessionKey, options = {}) {
+    return this.runRecallWithXrayCapture(
+      prompt,
+      sessionKey,
+      options,
+      options.abortSignal
+    );
+  }
+  async runRecallWithXrayCapture(prompt, sessionKey, options, queueAbortSignal) {
+    return this.xrayCaptureQueue.run(
+      () => this.invokeRecall(prompt, sessionKey, {
+        ...options,
+        xrayCapture: true
+      }),
+      {
+        read: () => this.getLastXraySnapshot(),
+        clear: () => this.clearLastXraySnapshot(),
+        restore: (snapshot) => {
+          this.lastXraySnapshot = snapshot;
+        }
+      },
+      queueAbortSignal
+    );
+  }
   async waitForDirectAnswerObservationIdle(timeoutMs = 6e4) {
     return this.recallIntrospection.waitForDirectAnswerObservationIdle(
       timeoutMs
@@ -22992,4 +23092,4 @@ export {
   blendGraphExpandedRecallScore,
   Orchestrator
 };
-//# sourceMappingURL=chunk-4273YO6I.js.map
+//# sourceMappingURL=chunk-5WJ4LBFR.js.map