@remnic/core 10.0.33 → 10.0.34

package/src/access-observe-helpers.ts

@@ -1,3 +1,5 @@
+import { isPreemptedExtraction } from "./abort-error.js";
+
 type PendingObservePreparation = {
   cancelled: boolean;
   scopeHint?: string;
@@ -49,6 +51,7 @@ export function pendingObserveScopeHint(options: {
 
 type PendingObserveExtraction = {
   promise: Promise<void>;
+  running: Promise<void>;
   controllers: Set<AbortController>;
 };
 
@@ -131,12 +134,17 @@ export class PendingObserveExtractionTracker {
     const previous = this.entries.get(key);
     const promise = previous
       ? Promise.allSettled([previous.promise, extraction]).then((results) => {
-          const rejected = results.find((result): result is PromiseRejectedResult => result.status === "rejected");
+          const rejected = results.find(
+            (result): result is PromiseRejectedResult =>
+              result.status === "rejected" &&
+              !(result.reason instanceof Error && isPreemptedExtraction(result.reason)),
+          );
           if (rejected) throw rejected.reason;
         })
       : extraction;
     const entry = {
       promise,
+      running: previous?.running ?? extraction,
       controllers: new Set(previous ? [...previous.controllers, controller] : [controller]),
     };
     this.entries.set(key, entry);
@@ -144,8 +152,8 @@ export class PendingObserveExtractionTracker {
       .then(() => {
         if (this.entries.get(key) === entry) this.entries.delete(key);
       })
-      .catch(() => {
-        // Keep a failed barrier visible to the next lifecycle flush.
+      .catch((error) => {
+        if (error instanceof Error && isPreemptedExtraction(error) && this.entries.get(key) === entry) this.entries.delete(key);
       });
   }
 
@@ -167,21 +175,30 @@ export class PendingObserveExtractionTracker {
     principal?: string,
     namespace?: string,
     scopeHint?: string,
+    reason?: Error,
   ): void {
     for (const reservation of this.preparations.get(sessionKey) ?? []) {
       if (!preparationMatchesScope(reservation, principal, namespace, scopeHint)) continue;
       reservation.cancelled = true;
     }
 
+    this.abortTracked(sessionKey, principal, namespace, reason);
+  }
+
+  private abortTracked(
+    sessionKey: string,
+    principal: string | undefined,
+    namespace: string | undefined,
+    reason?: Error,
+  ): void {
     for (const [key, entry] of this.entries) {
       const [entrySessionKey, entryPrincipal, entryNamespace] = key.split("\u0000");
       if (
         entrySessionKey !== sessionKey ||
         (principal !== undefined && entryPrincipal !== (principal ?? "")) ||
         (namespace !== undefined && entryNamespace !== (namespace ?? ""))
-      )
-        continue;
-      for (const controller of entry.controllers) controller.abort();
+      ) continue;
+      for (const controller of entry.controllers) controller.abort(reason);
     }
   }
 
@@ -192,15 +209,31 @@ export class PendingObserveExtractionTracker {
     abortSignal?: AbortSignal,
     registerCancellation?: (cancel: () => void) => void,
     scopeHint?: string,
+    preemptAfterAdmission?: () => void,
   ): Promise<void> {
     const key = this.key(sessionKey, principal, namespace);
+    let cancelled = abortSignal?.aborted === true;
     const abortTracked = (): void => {
+      cancelled = true;
       this.cancel(sessionKey, principal, namespace, scopeHint);
     };
     registerCancellation?.(abortTracked);
     abortSignal?.addEventListener("abort", abortTracked, { once: true });
     try {
       await this.waitForPreparations(sessionKey, principal, namespace, scopeHint);
+      if (cancelled || abortSignal?.aborted) return;
+      if (preemptAfterAdmission) {
+        preemptAfterAdmission();
+        const running = this.entries.get(key)?.running;
+        if (!running) return;
+        try {
+          await running;
+        } catch (error) {
+          if (this.entries.get(key)?.running === running) this.entries.delete(key);
+          if (!(error instanceof Error && isPreemptedExtraction(error))) throw error;
+        }
+        return;
+      }
       while (true) {
         const entry = this.entries.get(key);
         if (!entry) return;
@@ -209,6 +242,7 @@ export class PendingObserveExtractionTracker {
         } catch (error) {
           if (this.entries.get(key) !== entry) continue;
           this.entries.delete(key);
+          if (error instanceof Error && isPreemptedExtraction(error)) return;
           throw error;
         }
         if (this.entries.get(key) !== entry) continue;

package/src/access-observe-write-surface.ts

@@ -119,7 +119,8 @@ export interface AccessObserveWriteSurfaceDeps {
     sessionKey: string,
     principal?: string,
     namespace?: string,
-    scopeHint?: string
+    scopeHint?: string,
+    reason?: Error,
   ): void;
   resolveReadableNamespace(namespace: string | undefined, principal?: string): string;
   validateWriteCandidate(
@@ -146,9 +147,10 @@ export class AccessObserveWriteSurface {
     sessionKey: string,
     principal?: string,
     namespace?: string,
-    scopeHint?: string
+    scopeHint?: string,
+    reason?: Error,
   ): void {
-    this.pendingObserveExtractions.cancel(sessionKey, principal, namespace, scopeHint);
+    this.pendingObserveExtractions.cancel(sessionKey, principal, namespace, scopeHint, reason);
   }
   constructor(private readonly deps: AccessObserveWriteSurfaceDeps) {}
 
@@ -935,7 +937,8 @@ export class AccessObserveWriteSurface {
           namespace,
           abortSignal,
           registerCancellation,
-          scopeHint
+          scopeHint,
+          () => this.deps.orchestrator.extractionQueueCoordinator?.preemptRunning(),
         )
     );
   }

package/src/access-service-observe-lcm-parity.test.ts

@@ -614,20 +614,9 @@ test("#2128: chained observes remain behind one force-flush barrier", async () =
   await service.observe(observeRequest({ sessionKey, skipExtraction: false }));
   assert.equal(resolvers.length, 2);
 
-  let settled = false;
-  void flushPromise.then(
-    () => {
-      settled = true;
-    },
-    () => {
-      settled = true;
-    },
-  );
   resolvers[0]?.();
-  await new Promise<void>((resolve) => setImmediate(resolve));
-  assert.equal(settled, false);
-  resolvers[1]?.();
   assert.equal((await flushPromise).flushed, true);
+  assert.equal(resolvers.length, 2);
 });
 
 test("#2128: a failed observe extraction is consumed after force-flush reports it", async () => {

package/src/access-service-observe-scope.test.ts

@@ -34,6 +34,7 @@ import test from "node:test";
 
 import { EngramAccessService } from "./access-service.js";
 import { PendingObserveExtractionTracker } from "./access-observe-helpers.js";
+import { preemptedExtractionError } from "./abort-error.js";
 
 import { tokenCapabilityStore } from "./access-token-capabilities.js";
 import { resolveAuthorizedNamespaceWritablePreflight } from "./access-namespace-preflight.js";
@@ -250,6 +251,79 @@ test("#2128 pending observe preparation is a force-flush barrier", async () => {
   assert.equal(waited, true);
 });
 
+test("a preempted observe extraction does not block the next force-flush", async () => {
+  const tracker = new PendingObserveExtractionTracker();
+  const key = tracker.key("session-a", "alice", "default");
+  tracker.track(key, Promise.reject(preemptedExtractionError()), new AbortController());
+  await tracker.wait("session-a", "alice", "default");
+  tracker.track(key, Promise.reject(new Error("extraction failed")), new AbortController());
+  await assert.rejects(() => tracker.wait("session-a", "alice", "default"), /extraction failed/);
+});
+
+test("cancelling a tracked extraction with a preemption reason does not block the next flush", async () => {
+  const tracker = new PendingObserveExtractionTracker();
+  const controller = new AbortController();
+  const extraction = new Promise<void>((_resolve, reject) => {
+    controller.signal.addEventListener("abort", () => reject(controller.signal.reason), { once: true });
+  });
+  tracker.track(tracker.key("session-a", "alice", "default"), extraction, controller);
+  tracker.cancel("session-a", "alice", "default", undefined, preemptedExtractionError());
+  await tracker.wait("session-a", "alice", "default");
+});
+
+test("flush preemption waits for admission and does not cancel the preparation", async () => {
+  const tracker = new PendingObserveExtractionTracker();
+  const preparation = tracker.reserve("session-a");
+  const controller = new AbortController();
+  const extraction = new Promise<void>((_resolve, reject) => {
+    controller.signal.addEventListener("abort", () => reject(controller.signal.reason), { once: true });
+  });
+  tracker.track(tracker.key("session-a", "alice", "default"), extraction, controller);
+  let waited = false;
+  const pending = tracker.wait(
+    "session-a", "alice", "default", undefined, undefined, undefined,
+    () => controller.abort(preemptedExtractionError()),
+  ).then(() => { waited = true; });
+  await Promise.resolve();
+  assert.equal(waited, false);
+  assert.equal(preparation.isCancelled(), false);
+  preparation.release();
+  await pending;
+  assert.equal(waited, true);
+  assert.equal(preparation.isCancelled(), false);
+});
+
+test("a cancelled flush does not preempt after admission", async () => {
+  const tracker = new PendingObserveExtractionTracker();
+  const preparation = tracker.reserve("session-a");
+  let preempted = false;
+  let cancel: (() => void) | undefined;
+  const pending = tracker.wait(
+    "session-a", "alice", "default", undefined, (fn) => { cancel = fn; }, undefined, () => { preempted = true; },
+  );
+  await Promise.resolve();
+  cancel?.();
+  preparation.release();
+  await pending;
+  assert.equal(preempted, false);
+  assert.equal(preparation.isCancelled(), true);
+});
+
+test("flush preemption does not wait for a second queued extraction", async () => {
+  const tracker = new PendingObserveExtractionTracker();
+  const first = new AbortController();
+  const firstPromise = new Promise<void>((_resolve, reject) => {
+    first.signal.addEventListener("abort", () => reject(first.signal.reason), { once: true });
+  });
+  const secondPromise = new Promise<void>(() => {});
+  const key = tracker.key("session-a", "alice", "default");
+  tracker.track(key, firstPromise, first);
+  tracker.track(key, secondPromise, new AbortController());
+  await tracker.wait("session-a", "alice", "default", undefined, undefined, undefined, () => {
+    first.abort(preemptedExtractionError());
+  });
+});
+
 test("#2206 scoped wait ignores unresolved preparations with a different hint", async () => {
   const tracker = new PendingObserveExtractionTracker();
   const target = tracker.reserve("opaque-session", "projectTag:project-a");

package/src/access-service.ts

@@ -4396,9 +4396,10 @@ export class EngramAccessService extends SupportPassportAccessServiceBase {
     sessionKey: string,
     principal?: string,
     namespace?: string,
-    scopeHint?: string
+    scopeHint?: string,
+    reason?: Error,
   ): void {
-    this.accessObserveWriteSurface.cancelPendingObserveExtractions(sessionKey, principal, namespace, scopeHint);
+    this.accessObserveWriteSurface.cancelPendingObserveExtractions(sessionKey, principal, namespace, scopeHint, reason);
   }
   async lcmCompactionRecord(
     request: EngramAccessLcmCompactionRecordRequest

package/src/orchestration/extraction-queue-coordinator.ts

@@ -24,7 +24,7 @@
  * `queueBufferedExtraction` builder delegates push+scheduling here.
  */
 
-import { isAbortError } from "../abort-error.js";
+import { isAbortError, preemptedExtractionError } from "../abort-error.js";
 import { log } from "../logger.js";
 
 /**
@@ -40,6 +40,7 @@ export class ExtractionQueueCoordinator {
   /** Whether the serial drain loop is currently running. */
   private processing = false;
   private accepting = true;
+  private runningPreempt: (() => void) | undefined;
 
   /** Current queue depth (idle-wait + test seam). */
   get length(): number {
@@ -56,9 +57,14 @@ export class ExtractionQueueCoordinator {
    * the production entry point — the orchestrator's `queueBufferedExtraction`
    * builds each task closure and hands it here.
    */
-  enqueue(task: () => Promise<void>): boolean {
+  enqueue(task: () => Promise<void>, options?: { front?: boolean }): boolean {
     if (!this.accepting) return false;
-    this.queue.push(task);
+    if (options?.front) {
+      this.preemptRunning();
+      this.queue.unshift(task);
+    } else {
+      this.queue.push(task);
+    }
     if (!this.processing) {
       this.processing = true;
       this.processQueue().catch((err) => {
@@ -69,6 +75,34 @@ export class ExtractionQueueCoordinator {
     return true;
   }
 
+  /** Automatic extraction registers this so a fail-closed flush can abort it. */
+  beginPreemptable(abort: () => void): void {
+    this.runningPreempt = abort;
+  }
+
+  endPreemptable(): void {
+    this.runningPreempt = undefined;
+  }
+
+  preemptRunning(): void {
+    const abort = this.runningPreempt;
+    this.runningPreempt = undefined;
+    abort?.();
+  }
+  runPreemptable<T>(
+    preemptable: boolean,
+    parent: AbortSignal | undefined,
+    run: (signal: AbortSignal) => Promise<T>,
+  ): Promise<T> {
+    const preempt = new AbortController();
+    if (preemptable) this.beginPreemptable(() => preempt.abort(preemptedExtractionError()));
+    const signal = parent ? AbortSignal.any([parent, preempt.signal]) : preempt.signal;
+    return Promise.resolve(run(signal)).finally(() => {
+      if (preemptable) this.endPreemptable();
+    });
+  }
+
+
   /** Stop new producers from entering the queue. */
   stopAccepting(): void {
     this.accepting = false;

package/src/orchestration/extraction-run.ts

@@ -446,12 +446,10 @@ export class ExtractionRunCoordinator {
       bufferKey?: string;
       abortSignal?: AbortSignal;
       failOnExtractionFailure?: boolean;
-      /**
-       * Called immediately after durable extraction persistence returns, before
-       * any metadata, retention, or helper work. Lifecycle callers use this
-       * as the write-rate-limit commit boundary.
-       */
+      /** Write-rate commit boundary, after persistence returns. */
       onDurableCommit?: () => void;
+      /** Disarm preemption once persistence can no longer be aborted. */
+      onBeforePersist?: () => void;
       /**
        * Explicit namespace override for the write path (#460).  When set, this
        * is the namespace where extraction writes go instead of the one derived
@@ -550,8 +548,9 @@ export class ExtractionRunCoordinator {
         if (deadlineTimer) clearTimeout(deadlineTimer);
       }
     };
-    const clearBuffer = async (options?: { ignoreAbort?: boolean }) => {
-      if (options?.ignoreAbort !== true) {
+    const clearBuffer = async (clearOptions?: { ignoreAbort?: boolean }) => {
+      options.onBeforePersist?.();
+      if (clearOptions?.ignoreAbort !== true) {
         throwIfDeadlineExceeded("before_clear_buffer");
         throwIfAborted("before_clear_buffer");
       }
@@ -1063,6 +1062,7 @@ export class ExtractionRunCoordinator {
       }
     }
     const originContext = deriveExtractionOriginContext(targetTurns, result.sourceConnector);
+    options.onBeforePersist?.();
     throwIfDeadlineExceeded("before_persist");
     throwIfAborted("before_persist");
 

package/src/orchestration/session-context.ts

@@ -66,13 +66,8 @@ export interface SessionContextDeps {
       ) => void;
       bufferKey?: string;
       abortSignal?: AbortSignal;
-      /**
-       * Explicit namespace override for the write path (#460).  When set,
-       * `runExtraction` writes to this namespace instead of deriving one
-       * from `defaultNamespaceForPrincipal(resolvePrincipal(sessionKey))`.
-       * Used by bulk-import to pin writes to a deterministic namespace
-       * regardless of user-configured principal routing rules.
-       */
+      preemptable?: boolean;
+      preemptRunning?: boolean;
       writeNamespaceOverride?: string;
       /**
        * Pin the provenance principal (#1495 thread 1). Forwarded to
@@ -605,6 +600,8 @@ export class SessionContextCoordinator {
           skipCharThreshold: true,
           skipUserTurnThreshold: true,
           failOnExtractionFailure: options.failOnExtractionFailure === true,
+          preemptRunning:
+            options.reason === "access_force_flush" && options.failOnExtractionFailure === true,
           forceExtractionAttempt: true,
           abortSignal: options.abortSignal,
           extractionDeadlineMs: options.extractionDeadlineMs,

package/src/orchestration/turn-ingestion.ts

@@ -17,7 +17,7 @@
  */
 
 import { createHash, randomBytes } from "node:crypto";
-import { abortError } from "../abort-error.js";
+import { abortError, isPreemptedExtraction } from "../abort-error.js";
 import { SmartBuffer } from "../buffer.js";
 import type { ImportTurn } from "../bulk-import/types.js";
 import { resolveNamespaceCapabilities, resolvePipelineProcessingCapabilities, resolveRecallAuxiliaryCapabilities } from "../capabilities.js";
@@ -101,13 +101,8 @@ export interface TurnIngestionDeps {
       ) => void;
       bufferKey?: string;
       abortSignal?: AbortSignal;
-      /**
-       * Explicit namespace override for the write path (#460).  When set,
-       * `runExtraction` writes to this namespace instead of deriving one
-       * from `defaultNamespaceForPrincipal(resolvePrincipal(sessionKey))`.
-       * Used by bulk-import to pin writes to a deterministic namespace
-       * regardless of user-configured principal routing rules.
-       */
+      preemptable?: boolean;
+      preemptRunning?: boolean;
       writeNamespaceOverride?: string;
       /**
        * Pin the provenance principal (#1495 thread 1). Forwarded to
@@ -230,7 +225,7 @@ export class TurnIngestionCoordinator {
     await this.deps.queueBufferedExtraction(
       outcome.extractionTurns,
       "trigger_mode",
-      { bufferKey },
+      { bufferKey, preemptable: true },
     );
   }
 
@@ -496,6 +491,7 @@ export class TurnIngestionCoordinator {
         void this.deps.queueBufferedExtraction(group.turns, "trigger_mode", {
           bufferKey,
           clearMatchingTurns: true,
+          preemptable: true,
         }).catch((err) => log.error(`native trigger extraction failed: ${err}`));
         continue;
       }
@@ -513,9 +509,8 @@ export class TurnIngestionCoordinator {
           extractionDeadlineMs: options.deadlineMs,
           writeNamespaceOverride: group.writeNamespaceOverride,
           principalOverride: group.principalOverride,
-          // #3251: accepted groups with no plan pin dispatch null (explicit
-          // none) — not undefined which would re-resolve the CURRENT profile.
           scopeProfileWritePlan: group.scopeProfileWritePlan ?? null,
+          preemptable: true,
           onTaskSettled: (err) => (err ? reject(err) : resolve()),
         }).catch(reject);
       });
@@ -807,6 +802,7 @@ export class TurnIngestionCoordinator {
         }
         await this.deps.queueBufferedExtraction(turns, "heartbeat_observer", {
           bufferKey,
+          preemptable: true,
         });
       });
 
@@ -839,13 +835,10 @@ export class TurnIngestionCoordinator {
       ) => void;
       bufferKey?: string;
       abortSignal?: AbortSignal;
-      /**
-       * Explicit namespace override for the write path (#460).  When set,
-       * `runExtraction` writes to this namespace instead of deriving one
-       * from `defaultNamespaceForPrincipal(resolvePrincipal(sessionKey))`.
-       * Used by bulk-import to pin writes to a deterministic namespace
-       * regardless of user-configured principal routing rules.
-       */
+      /** Automatic buffered work only. Replay and import must not set this. */
+      preemptable?: boolean;
+      /** Fail-closed force-flush only. Not implied by failOnExtractionFailure. */
+      preemptRunning?: boolean;
       writeNamespaceOverride?: string;
       /**
        * Pin the provenance principal (#1495 thread 1). Forwarded to
@@ -931,8 +924,10 @@ export class TurnIngestionCoordinator {
       };
       scheduleQueueWaitTimeout();
     }
-
+    if (settled) return;
+    const preemptable = options.preemptable === true && options.preemptRunning !== true;
     const accepted = this.deps.extractionQueueCoordinator.enqueue(async () => {
+      await this.deps.extractionQueueCoordinator.runPreemptable(preemptable, options.abortSignal, async (abortSignal) => {
       if (settled) return;
       if (
         typeof extractionDeadlineMs === "number" &&
@@ -1081,7 +1076,8 @@ export class TurnIngestionCoordinator {
           deadlineMs: extractionDeadlineMs,
           bufferKey,
           onDurableCommit: options.onDurableCommit,
-          abortSignal: options.abortSignal,
+          onBeforePersist: () => this.deps.extractionQueueCoordinator.endPreemptable(),
+          abortSignal,
           failOnExtractionFailure: options.failOnExtractionFailure === true,
           writeNamespaceOverride: options.writeNamespaceOverride,
           principalOverride: options.principalOverride,
@@ -1090,11 +1086,14 @@ export class TurnIngestionCoordinator {
         });
         settleTask(undefined, result);
       } catch (err) {
-        if (settleTask(err)) {
-          throw err;
+        const reason = abortSignal.reason;
+        const settledError = reason instanceof Error && isPreemptedExtraction(reason) ? reason : err;
+        if (settleTask(settledError)) {
+          throw settledError;
         }
       }
-    });
+      });
+    }, { front: options.preemptRunning === true });
     if (!accepted) {
       settleTask(new Error("extraction queue is stopped"));
       return;

package/src/orchestrator-extraction-queue.test.ts

@@ -222,3 +222,51 @@ test("stopAccepting rejects new producers until resume", async () => {
   assert.equal(coordinator.enqueue(async () => {}), true);
   assert.equal(await coordinator.pauseAndDrain(), true);
 });
+
+test("a front enqueue aborts the running automatic task and runs before queued work", async () => {
+  const coordinator = createCoordinator();
+  const order: string[] = [];
+  const started = Promise.withResolvers<void>();
+  coordinator.enqueue(async () => {
+    const preempt = new AbortController();
+    coordinator.beginPreemptable(() => preempt.abort());
+    started.resolve();
+    try {
+      await new Promise<void>((_resolve, reject) => {
+        preempt.signal.addEventListener("abort", () => reject(abortError("preempted")), { once: true });
+      });
+      order.push("automatic-finished");
+    } finally {
+      coordinator.endPreemptable();
+    }
+  });
+  await started.promise;
+  coordinator.enqueue(async () => {
+    order.push("queued");
+  });
+  coordinator.enqueue(async () => {
+    order.push("flush");
+  }, { front: true });
+  await coordinator.waitForIdle();
+  assert.deepEqual(order, ["flush", "queued"]);
+});
+
+test("a front enqueue does not abort a task that did not register as preemptable", async () => {
+  const coordinator = createCoordinator();
+  const order: string[] = [];
+  const started = Promise.withResolvers<void>();
+  const release = Promise.withResolvers<void>();
+  coordinator.enqueue(async () => {
+    started.resolve();
+    await release.promise;
+    order.push("protected");
+  });
+  await started.promise;
+  coordinator.enqueue(async () => {
+    order.push("flush");
+  }, { front: true });
+  release.resolve();
+  await coordinator.waitForIdle();
+  assert.deepEqual(order, ["protected", "flush"]);
+});
+

package/src/orchestrator-flush.test.ts

@@ -112,6 +112,8 @@ test("flushSession queues extraction for the targeted buffered session", async (
   assert.equal(queuedCall.options?.clearBufferAfterExtraction, true);
   assert.equal(queuedCall.options?.skipDedupeCheck, true);
   assert.equal(queuedCall.options?.failOnExtractionFailure, true);
+  assert.equal(queuedCall.options?.preemptRunning, true);
+  assert.equal(queuedCall.options?.preemptable, undefined);
   assert.equal(queuedCall.options?.abortSignal, undefined);
   assert.equal(committed, 1);
 });

package/src/orchestrator.ts

@@ -3043,13 +3043,8 @@ export class Orchestrator {
       ) => void;
       bufferKey?: string;
       abortSignal?: AbortSignal;
-      /**
-       * Explicit namespace override for the write path (#460).  When set,
-       * `runExtraction` writes to this namespace instead of deriving one
-       * from `defaultNamespaceForPrincipal(resolvePrincipal(sessionKey))`.
-       * Used by bulk-import to pin writes to a deterministic namespace
-       * regardless of user-configured principal routing rules.
-       */
+      preemptable?: boolean;
+      preemptRunning?: boolean;
       writeNamespaceOverride?: string;
       /**
        * Pin the provenance principal (#1495 thread 1). Forwarded to

package/dist/chunk-BTTPKDIL.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/abort-error.ts"],"sourcesContent":["/**\n * Shared abort-error helpers.\n *\n * Consolidates the `throwIfAborted` / `abortError` / `isAbortError`\n * patterns that were independently implemented across\n * `direct-answer-wiring.ts`, `harmonic-retrieval.ts`, and `qmd.ts`\n * (plus a private pair in `orchestrator.ts`).  A single helper\n * means future changes to the abort-error convention are applied\n * consistently across the codebase.\n *\n * The convention (matching Web / Node): throw a standard `Error`\n * with `name === \"AbortError\"`.  Callers dispatch on name rather\n * than a specific class so error propagation across async\n * boundaries continues to classify correctly.\n */\n\n/**\n * Build an Error whose `name` is `\"AbortError\"`.  Uses\n * `Object.defineProperty` so the name is non-enumerable and\n * mirrors the shape of `DOMException(\"AbortError\")` where that\n * is available.\n */\nexport function abortError(message: string): Error {\n  const err = new Error(message);\n  Object.defineProperty(err, \"name\", { value: \"AbortError\" });\n  return err;\n}\n\n/** Return true iff `err` is an Error whose `name` is `\"AbortError\"`. */\nexport function isAbortError(err: unknown): boolean {\n  return err instanceof Error && err.name === \"AbortError\";\n}\n\n/**\n * Throw an AbortError when the given signal has fired.  No-op\n * when the signal is absent or not yet aborted.  The default\n * message matches the prior in-module implementations.\n */\nexport function throwIfAborted(\n  signal?: AbortSignal,\n  message = \"operation aborted\",\n): void {\n  if (signal?.aborted) {\n    throw abortError(message);\n  }\n}\n\nexport function raceAbort<T>(\n  promise: Promise<T>,\n  signal?: AbortSignal,\n  message = \"operation aborted\",\n): Promise<T> {\n  if (!signal) return promise;\n  if (signal.aborted) return Promise.reject(abortError(message));\n  let onAbort: (() => void) | undefined;\n  const aborted = new Promise<never>((_resolve, reject) => {\n    onAbort = () => reject(abortError(message));\n    signal.addEventListener(\"abort\", onAbort, { once: true });\n  });\n  return Promise.race([promise, aborted]).finally(() => {\n    if (onAbort) signal.removeEventListener(\"abort\", onAbort);\n  });\n}\n"],"mappings":";AAsBO,SAAS,WAAW,SAAwB;AACjD,QAAM,MAAM,IAAI,MAAM,OAAO;AAC7B,SAAO,eAAe,KAAK,QAAQ,EAAE,OAAO,aAAa,CAAC;AAC1D,SAAO;AACT;AAGO,SAAS,aAAa,KAAuB;AAClD,SAAO,eAAe,SAAS,IAAI,SAAS;AAC9C;AAOO,SAAS,eACd,QACA,UAAU,qBACJ;AACN,MAAI,QAAQ,SAAS;AACnB,UAAM,WAAW,OAAO;AAAA,EAC1B;AACF;AAEO,SAAS,UACd,SACA,QACA,UAAU,qBACE;AACZ,MAAI,CAAC,OAAQ,QAAO;AACpB,MAAI,OAAO,QAAS,QAAO,QAAQ,OAAO,WAAW,OAAO,CAAC;AAC7D,MAAI;AACJ,QAAM,UAAU,IAAI,QAAe,CAAC,UAAU,WAAW;AACvD,cAAU,MAAM,OAAO,WAAW,OAAO,CAAC;AAC1C,WAAO,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;AAAA,EAC1D,CAAC;AACD,SAAO,QAAQ,KAAK,CAAC,SAAS,OAAO,CAAC,EAAE,QAAQ,MAAM;AACpD,QAAI,QAAS,QAAO,oBAAoB,SAAS,OAAO;AAAA,EAC1D,CAAC;AACH;","names":[]}