@remnic/core 9.6.28 → 9.6.29

package/dist/{chunk-YDF4HL3W.js → chunk-5BHIGBHQ.js}

@@ -6511,37 +6511,37 @@ var AccessRecallSurface = class {
     }
     const mode = this.deps.normalizeRecallMode(request.mode);
     const disclosure = request.disclosure ?? DEFAULT_RECALL_DISCLOSURE;
-    const previousQueue = this.deps.xrayQueue;
-    let release = () => {
-    };
-    this.deps.xrayQueue = new Promise((resolve4) => {
-      release = resolve4;
-    });
-    await previousQueue;
-    const recallStartedAt = Date.now();
+    let recallStartedAt = Date.now();
     const recallSessionKey = request.sessionKey?.trim() || void 0;
     let xrayResponse = { snapshotFound: false };
-    try {
-      this.deps.orchestrator.clearLastXraySnapshot();
-      await this.deps.orchestrator.recall(query, recallSessionKey, {
-        xrayCapture: true,
-        ...requestedNamespace ? { namespace: requestedNamespace } : {},
-        ...budgetOverride !== void 0 ? { budgetCharsOverride: budgetOverride } : {},
-        ...mode !== void 0 ? { mode } : {},
-        // When the caller supplies an authenticated principal, forward
-        // it via the dedicated override channel so orchestrator-side
-        // ACL decisions use the SAME principal the access-surface
-        // pre-check above authorized.  Threading an
-        // `authenticatedPrincipal` through `sessionKey` would be wrong:
-        // `resolvePrincipal(sessionKey)` only maps configured raw
-        // session keys and otherwise collapses to `"default"`, which
-        // in namespace-enabled deployments produces false denials /
-        // wrong-scope serving despite the pre-check passing
-        // (CLAUDE.md rule 42).
-        ...authenticatedPrincipal ? { principalOverride: authenticatedPrincipal } : {},
-        ...request.currentContextScopes !== void 0 ? { currentContextScopes: request.currentContextScopes } : {}
-      });
-      const rawSnapshot = this.deps.orchestrator.getLastXraySnapshot();
+    {
+      const {
+        snapshot: rawSnapshot,
+        recallStartedAt: capturedRecallStartedAt
+      } = await this.deps.orchestrator.recallWithXrayCapture(
+        query,
+        recallSessionKey,
+        {
+          ...requestedNamespace ? { namespace: requestedNamespace } : {},
+          ...budgetOverride !== void 0 ? { budgetCharsOverride: budgetOverride } : {},
+          ...mode !== void 0 ? { mode } : {},
+          // When the caller supplies an authenticated principal, forward
+          // it via the dedicated override channel so orchestrator-side
+          // ACL decisions use the SAME principal the access-surface
+          // pre-check above authorized.  Threading an
+          // `authenticatedPrincipal` through `sessionKey` would be wrong:
+          // `resolvePrincipal(sessionKey)` only maps configured raw
+          // session keys and otherwise collapses to `"default"`, which
+          // in namespace-enabled deployments produces false denials /
+          // wrong-scope serving despite the pre-check passing
+          // (CLAUDE.md rule 42).
+          ...authenticatedPrincipal ? { principalOverride: authenticatedPrincipal } : {},
+          ...request.currentContextScopes !== void 0 ? { currentContextScopes: request.currentContextScopes } : {},
+          ...request.abortSignal ? { abortSignal: request.abortSignal } : {}
+        }
+      );
+      recallStartedAt = capturedRecallStartedAt;
+      throwIfAborted(request.abortSignal, "recall X-ray aborted before postprocessing");
       const namespaceMismatch = requestedNamespace !== void 0 && rawSnapshot?.namespace !== requestedNamespace;
       if (!rawSnapshot) {
         xrayResponse = { snapshotFound: false };
@@ -6656,8 +6656,6 @@ var AccessRecallSurface = class {
           };
         }
       }
-    } finally {
-      release();
     }
     if (request.includeRecall === true && xrayResponse.snapshotFound === true && xrayResponse.snapshot) {
       const xrayRawExcerptNamespace = disclosure === "raw" ? this.deps.resolveRawExcerptReadNamespace(
@@ -8162,11 +8160,6 @@ var EngramAccessService = class {
       request
     );
   }
-  // Sequence lock for `recallXray` — see comment inside the method.
-  // Lives on the instance so every x-ray call on the same service
-  // shares it, and so separate services in the same process (e.g.
-  // per-tenant) do not block each other.
-  xrayQueue = Promise.resolve();
   async memoryStore(request, hooks) {
     return this.accessObserveWriteSurface.memoryStore(
       request,
@@ -10928,4 +10921,4 @@ export {
   EngramAccessService,
   AccessAdminOpsSurface
 };
-//# sourceMappingURL=chunk-YDF4HL3W.js.map
+//# sourceMappingURL=chunk-5BHIGBHQ.js.map