@remnic/core 9.47.1 → 9.48.0

package/dist/{chunk-64BHFFKZ.js → chunk-2RPJ4NEE.js}

@@ -13,7 +13,7 @@ import {
 } from "./chunk-H3FZVNRN.js";
 import {
   ExtractionDeadlineError
-} from "./chunk-N3LL5NEU.js";
+} from "./chunk-WQIHRA5F.js";
 import {
   resolvePrincipal
 } from "./chunk-3GD2HFR6.js";
@@ -792,4 +792,4 @@ var SmartBuffer = class {
 export {
   SmartBuffer
 };
-//# sourceMappingURL=chunk-64BHFFKZ.js.map
+//# sourceMappingURL=chunk-2RPJ4NEE.js.map

package/dist/{chunk-JFO5QZ7N.js → chunk-3JUYWPFJ.js}

@@ -1,6 +1,6 @@
 import {
   rebuildMemoryProjection
-} from "./chunk-WOC6DXP5.js";
+} from "./chunk-M4DMO67I.js";
 
 // src/convergence-refresh.ts
 async function refreshConvergedNamespaces(namespaces, namespaceSearchRouter, getStorage, searchEnabled) {
@@ -32,4 +32,4 @@ async function refreshConvergedNamespaces(namespaces, namespaceSearchRouter, get
 export {
   refreshConvergedNamespaces
 };
-//# sourceMappingURL=chunk-JFO5QZ7N.js.map
+//# sourceMappingURL=chunk-3JUYWPFJ.js.map

package/dist/{chunk-L7G72WY4.js → chunk-3NDN5P55.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-IDE5AR5W.js";
+} from "./chunk-PLCZD3LG.js";
 import {
   normalizeEntityName
 } from "./chunk-YXZG5TVN.js";
@@ -958,4 +958,4 @@ export {
   resolveBriefingSaveDir,
   briefingFilename
 };
-//# sourceMappingURL=chunk-L7G72WY4.js.map
+//# sourceMappingURL=chunk-3NDN5P55.js.map

package/dist/{chunk-IXH2U2QT.js → chunk-45OTV7FZ.js}

@@ -45,7 +45,7 @@ import {
 } from "./chunk-P2OTGMTR.js";
 import {
   readAggregateExtractionWatermark
-} from "./chunk-KA47C7BF.js";
+} from "./chunk-RSPSHRZA.js";
 import {
   ReplicaDivergenceMonitor
 } from "./chunk-CVILPI77.js";
@@ -61,9 +61,6 @@ import {
 import {
   buildGraphSnapshot
 } from "./chunk-JYIFGGEM.js";
-import {
-  REDACTION_RULES_SUBDIR
-} from "./chunk-LTHVM4XN.js";
 import {
   wrapWorkLayerContext
 } from "./chunk-EI6V5UXY.js";
@@ -80,6 +77,9 @@ import {
   buildProcedurePersistBody,
   normalizeProcedureSteps
 } from "./chunk-QDW3E4RD.js";
+import {
+  REDACTION_RULES_SUBDIR
+} from "./chunk-LTHVM4XN.js";
 import {
   persistExplicitCapture,
   queueExplicitCaptureForReview,
@@ -88,6 +88,13 @@ import {
 import {
   lcmEvidenceIdentity
 } from "./chunk-C37ZRXX7.js";
+import {
+  CorpusWatermarkCache,
+  computeServiceCorpusCensus
+} from "./chunk-JYPO7L3G.js";
+import {
+  namespaceCollectionName
+} from "./chunk-PRVJH7CY.js";
 import {
   CrossNamespaceBudget,
   toBudgetWarning
@@ -99,14 +106,7 @@ import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   runMemoryGovernance
-} from "./chunk-V5FE3UAI.js";
-import {
-  CorpusWatermarkCache,
-  computeServiceCorpusCensus
-} from "./chunk-PFJXPOD4.js";
-import {
-  namespaceCollectionName
-} from "./chunk-KMWYZTIE.js";
+} from "./chunk-WOEVJKKQ.js";
 import {
   defaultCapsulesDir
 } from "./chunk-ZY2MNJR6.js";
@@ -120,14 +120,14 @@ import {
   enqueuePassiveCorrectionNotification,
   parseBriefingFocus,
   parseBriefingWindow
-} from "./chunk-L7G72WY4.js";
+} from "./chunk-3NDN5P55.js";
 import {
   parseEntityFile,
   parseFrontmatter,
   qmdCollectionPathParts,
   qmdResultPathCandidates,
   selfDeps
-} from "./chunk-IDE5AR5W.js";
+} from "./chunk-PLCZD3LG.js";
 import {
   DEFAULT_RECALL_DISCLOSURE,
   isRecallDisclosure
@@ -162,7 +162,7 @@ import {
   isActivityDigestPath,
   isArtifactMemoryPath,
   isMeetingRecordPath
-} from "./chunk-N3LL5NEU.js";
+} from "./chunk-WQIHRA5F.js";
 import {
   ExtractionLivenessWarnThrottle,
   computeExtractionLivenessStatus
@@ -208,10 +208,10 @@ import {
 } from "./chunk-LNEWDF2A.js";
 import {
   createOfflineSyncManifestStream
-} from "./chunk-BIPBQQFI.js";
+} from "./chunk-UMOO7IY7.js";
 import {
   offlineSyncStorageForSnapshot
-} from "./chunk-5U7ID3EZ.js";
+} from "./chunk-UTVZKHJK.js";
 import {
   resolveScopePlan,
   resolveScopedWritableNamespaceValue,
@@ -317,7 +317,7 @@ import {
 } from "./chunk-BTTPKDIL.js";
 import {
   AccessAuditAdapter
-} from "./chunk-TVVEYCNW.js";
+} from "./chunk-7K5Q6COX.js";
 import {
   decodeCitationNamespace
 } from "./chunk-JIYDRBVZ.js";
@@ -13523,4 +13523,4 @@ export {
   EngramAccessService,
   AccessAdminOpsSurface
 };
-//# sourceMappingURL=chunk-IXH2U2QT.js.map
+//# sourceMappingURL=chunk-45OTV7FZ.js.map

package/dist/chunk-4O4TKIXQ.js

@@ -0,0 +1,171 @@
+import {
+  abortError,
+  isAbortError
+} from "./chunk-BTTPKDIL.js";
+import {
+  log
+} from "./chunk-3WCASNQZ.js";
+
+// src/recall-qos.ts
+function yieldToEventLoop() {
+  const { promise, resolve } = Promise.withResolvers();
+  setImmediate(resolve);
+  return promise;
+}
+function defaultTiming(metric) {
+  if (typeof metric.timing === "string" && metric.timing.length > 0) {
+    return metric.timing;
+  }
+  if (metric.source === "timeout") {
+    return `timeout(${Math.max(0, Math.round(metric.durationMs))}ms)`;
+  }
+  if (metric.source === "skip") {
+    return "skip";
+  }
+  return `${Math.max(0, Math.round(metric.durationMs))}ms`;
+}
+function formatRecallSectionMetric(metric) {
+  const payload = {
+    section: metric.section,
+    priority: metric.priority,
+    durationMs: metric.durationMs,
+    deadlineMs: metric.deadlineMs,
+    source: metric.source,
+    success: metric.success
+  };
+  return {
+    message: "recall section metric",
+    payload,
+    level: metric.priority === "core" && metric.success && metric.source !== "skip" ? "info" : "debug",
+    timing: defaultTiming(metric)
+  };
+}
+function createRecallSectionMetricRecorder(options = {}) {
+  const logger = options.logger ?? log;
+  return (metric) => {
+    const entry = formatRecallSectionMetric(metric);
+    if (options.timings) {
+      options.timings[metric.section] = entry.timing;
+    }
+    if (entry.level === "info") {
+      if (typeof logger.info === "function") {
+        logger.info(entry.message, entry.payload);
+      } else {
+        log.info(entry.message, entry.payload);
+      }
+    } else {
+      if (typeof logger.debug === "function") {
+        logger.debug(entry.message, entry.payload);
+      } else {
+        log.debug(entry.message, entry.payload);
+      }
+    }
+    return entry;
+  };
+}
+var CORE_SECTION_MAX_SHARE_OF_REQUEST = 0.8;
+function resolveRecallCoreSectionDeadlineMs(options) {
+  const configured = options.configuredCoreDeadlineMs;
+  if (!Number.isFinite(configured) || configured <= 0) return configured;
+  const remaining = options.remainingOuterMs;
+  if (remaining === null || !Number.isFinite(remaining)) return configured;
+  if (remaining <= 0) return 1;
+  return Math.min(
+    configured,
+    Math.max(1, Math.floor(remaining * CORE_SECTION_MAX_SHARE_OF_REQUEST))
+  );
+}
+async function runRecallSectionWithinDeadline(options) {
+  const now = options.now ?? Date.now;
+  const startedAtMs = now();
+  const controller = new AbortController();
+  const parentSignal = options.parentSignal;
+  const onParentAbort = () => controller.abort();
+  if (parentSignal?.aborted) {
+    controller.abort();
+  } else if (parentSignal) {
+    parentSignal.addEventListener("abort", onParentAbort, { once: true });
+  }
+  const bounded = Number.isFinite(options.deadlineMs) && options.deadlineMs > 0;
+  let timer;
+  try {
+    const work = options.run(controller.signal).then(
+      (value) => ({ kind: "value", value })
+    );
+    if (!bounded) {
+      const settled2 = await work;
+      return { value: settled2.value, timedOut: false, durationMs: now() - startedAtMs };
+    }
+    const deadline = Promise.withResolvers();
+    timer = setTimeout(() => deadline.resolve({ kind: "timeout" }), options.deadlineMs);
+    const settled = await Promise.race([work, deadline.promise]);
+    if (settled.kind === "timeout") {
+      controller.abort(abortError("recall section deadline exceeded"));
+      void work.catch(() => {
+      });
+      return { value: options.fallback, timedOut: true, durationMs: now() - startedAtMs };
+    }
+    return { value: settled.value, timedOut: false, durationMs: now() - startedAtMs };
+  } finally {
+    clearTimeout(timer);
+    parentSignal?.removeEventListener("abort", onParentAbort);
+  }
+}
+function createBoundedCoreSectionRunner(options) {
+  const logger = options.logger ?? log;
+  const now = options.now ?? Date.now;
+  return async (section, fallback, run) => {
+    const startedAtMs = now();
+    const deadlineMs = resolveRecallCoreSectionDeadlineMs({
+      configuredCoreDeadlineMs: options.configuredDeadlineMs,
+      remainingOuterMs: options.outerDeadlineAtMs === null ? null : options.outerDeadlineAtMs - startedAtMs
+    });
+    let outcome;
+    try {
+      outcome = await runRecallSectionWithinDeadline({
+        deadlineMs,
+        fallback,
+        parentSignal: options.parentSignal,
+        run,
+        now
+      });
+    } catch (err) {
+      if (!isAbortError(err)) throw err;
+      const durationMs = now() - startedAtMs;
+      options.record({
+        section,
+        priority: "core",
+        durationMs,
+        deadlineMs,
+        source: "skip",
+        success: false,
+        timing: `cancelled(${durationMs}ms)`
+      });
+      return fallback;
+    }
+    if (outcome.timedOut) {
+      logger.warn(
+        `recall section [${section}] exceeded its ${deadlineMs}ms core deadline after ${outcome.durationMs}ms; recall continues without it`
+      );
+    }
+    options.record({
+      section,
+      priority: "core",
+      durationMs: outcome.durationMs,
+      deadlineMs,
+      source: outcome.timedOut ? "timeout" : "fresh",
+      success: !outcome.timedOut
+    });
+    return outcome.value;
+  };
+}
+
+export {
+  yieldToEventLoop,
+  formatRecallSectionMetric,
+  createRecallSectionMetricRecorder,
+  resolveRecallCoreSectionDeadlineMs,
+  runRecallSectionWithinDeadline,
+  createBoundedCoreSectionRunner
+};
+//# sourceMappingURL=chunk-4O4TKIXQ.js.map

package/dist/chunk-4O4TKIXQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/recall-qos.ts"],"sourcesContent":["import { abortError, isAbortError } from \"./abort-error.js\";\nimport { log, type LoggerBackend } from \"./logger.js\";\n\n/**\n * Hand the event loop one macrotask.\n *\n * A recall section deadline is a timer, and a timer cannot fire while a\n * synchronous scan holds the loop — so a provider that iterates the whole corpus\n * must call this periodically or its budget is unenforceable (issue #2291).\n * `setImmediate` (check phase) is used rather than a `0ms` timer so the yield\n * cannot be starved by the timer queue it exists to let run.\n */\nexport function yieldToEventLoop(): Promise<void> {\n  const { promise, resolve } = Promise.withResolvers<void>();\n  setImmediate(resolve);\n  return promise;\n}\n\nexport type RecallSectionPriority = \"core\" | \"enrichment\";\n/**\n * `timeout` records a section that started, exceeded its deadline, and was\n * degraded to its neutral value (issue #2291).  It is distinct from `skip`\n * (never ran: disabled or zero-limit) so operators can tell a configuration\n * choice from a budget breach in the section metric log.\n */\nexport type RecallSectionSource = \"fresh\" | \"stale\" | \"skip\" | \"timeout\";\n\nexport interface RecallSectionMetric {\n  section: string;\n  priority: RecallSectionPriority;\n  durationMs: number;\n  deadlineMs: number;\n  source: RecallSectionSource;\n  success: boolean;\n  timing?: string;\n}\n\nexport interface RecallSectionMetricLog {\n  message: string;\n  payload: {\n    section: string;\n    priority: RecallSectionPriority;\n    durationMs: number;\n    deadlineMs: number;\n    source: RecallSectionSource;\n    success: boolean;\n  };\n  level: \"info\" | \"debug\";\n  timing: string;\n}\n\nfunction defaultTiming(metric: RecallSectionMetric): string {\n  if (typeof metric.timing === \"string\" && metric.timing.length > 0) {\n    return metric.timing;\n  }\n  if (metric.source === \"timeout\") {\n    return `timeout(${Math.max(0, Math.round(metric.durationMs))}ms)`;\n  }\n  if (metric.source === \"skip\") {\n    return \"skip\";\n  }\n  return `${Math.max(0, Math.round(metric.durationMs))}ms`;\n}\n\nexport function formatRecallSectionMetric(metric: RecallSectionMetric): RecallSectionMetricLog {\n  const payload = {\n    section: metric.section,\n    priority: metric.priority,\n    durationMs: metric.durationMs,\n    deadlineMs: metric.deadlineMs,\n    source: metric.source,\n    success: metric.success,\n  };\n  return {\n    message: \"recall section metric\",\n    payload,\n    level: metric.priority === \"core\" && metric.success && metric.source !== \"skip\" ? \"info\" : \"debug\",\n    timing: defaultTiming(metric),\n  };\n}\n\nexport function createRecallSectionMetricRecorder(options: {\n  timings?: Record<string, string>;\n  logger?: Pick<LoggerBackend, \"info\" | \"debug\">;\n} = {}) {\n  const logger = options.logger ?? log;\n  return (metric: RecallSectionMetric): RecallSectionMetricLog => {\n    const entry = formatRecallSectionMetric(metric);\n    if (options.timings) {\n      options.timings[metric.section] = entry.timing;\n    }\n    if (entry.level === \"info\") {\n      if (typeof logger.info === \"function\") {\n        logger.info(entry.message, entry.payload);\n      } else {\n        log.info(entry.message, entry.payload);\n      }\n    } else {\n      if (typeof logger.debug === \"function\") {\n        logger.debug(entry.message, entry.payload);\n      } else {\n        log.debug(entry.message, entry.payload);\n      }\n    }\n    return entry;\n  };\n}\n\n/**\n * Fraction of the request's REMAINING budget that a single core section may\n * consume.  The remainder is what makes degradation possible at all: time to\n * assemble and return the sections that did arrive before the outer timeout\n * kills the request outright.\n */\nconst CORE_SECTION_MAX_SHARE_OF_REQUEST = 0.8;\n\n/**\n * Effective per-section deadline for optional core recall providers.\n *\n * Two things make the configured value unusable as-is (issue #2291):\n *\n *  - `recallCoreDeadlineMs` and `recallOuterTimeoutMs` both default to 75s, so a\n *    section budget taken at face value can never fire before the request ceiling\n *    that cancels everything — the caller loses the whole recall rather than one\n *    section.\n *  - Sections start *after* planning, namespace resolution, and mode selection.\n *    Capping against the original ceiling would let a section that starts 20s in\n *    still be running when the request is aborted, which is the same failure.\n *\n * So the cap is taken against `remainingOuterMs` — the request budget left when\n * the section actually starts. An operator who lowers `recallCoreDeadlineMs`\n * below that still gets exactly what they asked for.\n *\n * `remainingOuterMs === null` means the request is unbounded and there is nothing\n * to reserve headroom against. A non-positive remainder means the request is\n * already over budget, so the section degrades immediately rather than starting\n * work that cannot be delivered.\n */\nexport function resolveRecallCoreSectionDeadlineMs(options: {\n  configuredCoreDeadlineMs: number;\n  remainingOuterMs: number | null;\n}): number {\n  const configured = options.configuredCoreDeadlineMs;\n  if (!Number.isFinite(configured) || configured <= 0) return configured;\n  const remaining = options.remainingOuterMs;\n  if (remaining === null || !Number.isFinite(remaining)) return configured;\n  if (remaining <= 0) return 1;\n  return Math.min(\n    configured,\n    Math.max(1, Math.floor(remaining * CORE_SECTION_MAX_SHARE_OF_REQUEST)),\n  );\n}\n\nexport interface RecallSectionDeadlineOutcome<T> {\n  /** The section's value, or `fallback` when the deadline was exceeded. */\n  value: T;\n  timedOut: boolean;\n  durationMs: number;\n}\n\n/**\n * Run one recall section under a deadline, degrading to `fallback` instead of\n * blocking the phase it belongs to (issue #2291).\n *\n * Before this existed, `deadlineMs` was recorded in the section metric but\n * never enforced for core sections: a provider doing a multi-minute scan on a\n * slow filesystem blocked the whole phase-one `Promise.all`, and kept scanning\n * after the caller aborted.  Two guarantees fix that:\n *\n *  1. The returned promise settles within `deadlineMs`, with `timedOut: true`\n *     and the caller's neutral value, so one slow optional provider degrades\n *     independently rather than holding the response.\n *  2. `run` receives a signal that fires on the deadline AND on the caller's\n *     abort, so the section can stop its own work at its next checkpoint.\n *\n * `deadlineMs <= 0` (or non-finite) means unbounded, matching the config\n * contract that a zero budget disables the limit.  The section signal is still\n * created and still tracks the parent, so cancellation propagates either way.\n */\nexport async function runRecallSectionWithinDeadline<T>(options: {\n  deadlineMs: number;\n  fallback: T;\n  parentSignal?: AbortSignal;\n  run: (sectionSignal: AbortSignal) => Promise<T>;\n  now?: () => number;\n}): Promise<RecallSectionDeadlineOutcome<T>> {\n  const now = options.now ?? Date.now;\n  const startedAtMs = now();\n  const controller = new AbortController();\n  const parentSignal = options.parentSignal;\n  const onParentAbort = () => controller.abort();\n  if (parentSignal?.aborted) {\n    controller.abort();\n  } else if (parentSignal) {\n    parentSignal.addEventListener(\"abort\", onParentAbort, { once: true });\n  }\n\n  const bounded = Number.isFinite(options.deadlineMs) && options.deadlineMs > 0;\n  let timer: NodeJS.Timeout | undefined;\n\n  try {\n    // Wrap in a tagged result rather than racing raw values against a sentinel:\n    // T is caller-chosen and must never be mistaken for the timeout marker.\n    const work = options.run(controller.signal).then(\n      (value) => ({ kind: \"value\" as const, value }),\n    );\n    if (!bounded) {\n      const settled = await work;\n      return { value: settled.value, timedOut: false, durationMs: now() - startedAtMs };\n    }\n    const deadline = Promise.withResolvers<{ kind: \"timeout\" }>();\n    // Deliberately NOT unref'd: the caller is awaiting this bound, so the timer\n    // must keep the loop alive until it fires or `finally` clears it.\n    timer = setTimeout(() => deadline.resolve({ kind: \"timeout\" }), options.deadlineMs);\n    const settled = await Promise.race([work, deadline.promise]);\n    if (settled.kind === \"timeout\") {\n      controller.abort(abortError(\"recall section deadline exceeded\"));\n      // The abandoned work outlives this call; swallow its settlement so a\n      // late rejection is not reported as unhandled.\n      void work.catch(() => {});\n      return { value: options.fallback, timedOut: true, durationMs: now() - startedAtMs };\n    }\n    return { value: settled.value, timedOut: false, durationMs: now() - startedAtMs };\n  } finally {\n    clearTimeout(timer);\n    parentSignal?.removeEventListener(\"abort\", onParentAbort);\n  }\n}\n\n/**\n * Runs one *optional* core recall section, bounded and accounted for.\n *\n * Binds a section's deadline, the caller's abort signal, and the QoS recorder\n * once so each provider is one call (issue #2291).  A breach degrades the\n * section to `fallback`, warns with the section name and budget, and records the\n * section as `timeout` — so a slow provider costs its own section, not the\n * response.\n *\n * The budget is resolved when each section STARTS, against the request budget\n * still left at that moment (`outerDeadlineAtMs`), not against the original\n * configured ceiling: sections begin after planning and namespace resolution, and\n * a section sized to the full request would otherwise still be running when the\n * request itself is aborted.\n *\n * Cancellation degrades too, and must: the section signal fires on the caller's\n * abort, and the phase this section belongs to is awaited through a race that the\n * caller's abort also wins.  A rejection here would therefore land on a promise\n * nobody is awaiting any more — an unhandled rejection rather than a signal.  The\n * caller learns of its own abort from that race, not from a section result.\n *\n * Only sections whose absence leaves recall coherent belong here: the fallback\n * IS the degraded contract.\n */\nexport function createBoundedCoreSectionRunner(options: {\n  configuredDeadlineMs: number;\n  /** Absolute time the whole request is aborted, or null when unbounded. */\n  outerDeadlineAtMs: number | null;\n  parentSignal?: AbortSignal;\n  record: (metric: RecallSectionMetric) => unknown;\n  logger?: Pick<LoggerBackend, \"warn\">;\n  now?: () => number;\n}): <T>(\n  section: string,\n  fallback: T,\n  run: (sectionSignal: AbortSignal) => Promise<T>,\n) => Promise<T> {\n  const logger = options.logger ?? log;\n  const now = options.now ?? Date.now;\n  return async <T>(\n    section: string,\n    fallback: T,\n    run: (sectionSignal: AbortSignal) => Promise<T>,\n  ): Promise<T> => {\n    const startedAtMs = now();\n    const deadlineMs = resolveRecallCoreSectionDeadlineMs({\n      configuredCoreDeadlineMs: options.configuredDeadlineMs,\n      remainingOuterMs:\n        options.outerDeadlineAtMs === null ? null : options.outerDeadlineAtMs - startedAtMs,\n    });\n    let outcome: RecallSectionDeadlineOutcome<T>;\n    try {\n      outcome = await runRecallSectionWithinDeadline({\n        deadlineMs,\n        fallback,\n        parentSignal: options.parentSignal,\n        run,\n        now,\n      });\n    } catch (err) {\n      if (!isAbortError(err)) throw err;\n      const durationMs = now() - startedAtMs;\n      options.record({\n        section,\n        priority: \"core\",\n        durationMs,\n        deadlineMs,\n        source: \"skip\",\n        success: false,\n        timing: `cancelled(${durationMs}ms)`,\n      });\n      return fallback;\n    }\n    if (outcome.timedOut) {\n      logger.warn(\n        `recall section [${section}] exceeded its ${deadlineMs}ms core deadline ` +\n          `after ${outcome.durationMs}ms; recall continues without it`,\n      );\n    }\n    options.record({\n      section,\n      priority: \"core\",\n      durationMs: outcome.durationMs,\n      deadlineMs,\n      source: outcome.timedOut ? \"timeout\" : \"fresh\",\n      success: !outcome.timedOut,\n    });\n    return outcome.value;\n  };\n}"],"mappings":";;;;;;;;;AAYO,SAAS,mBAAkC;AAChD,QAAM,EAAE,SAAS,QAAQ,IAAI,QAAQ,cAAoB;AACzD,eAAa,OAAO;AACpB,SAAO;AACT;AAmCA,SAAS,cAAc,QAAqC;AAC1D,MAAI,OAAO,OAAO,WAAW,YAAY,OAAO,OAAO,SAAS,GAAG;AACjE,WAAO,OAAO;AAAA,EAChB;AACA,MAAI,OAAO,WAAW,WAAW;AAC/B,WAAO,WAAW,KAAK,IAAI,GAAG,KAAK,MAAM,OAAO,UAAU,CAAC,CAAC;AAAA,EAC9D;AACA,MAAI,OAAO,WAAW,QAAQ;AAC5B,WAAO;AAAA,EACT;AACA,SAAO,GAAG,KAAK,IAAI,GAAG,KAAK,MAAM,OAAO,UAAU,CAAC,CAAC;AACtD;AAEO,SAAS,0BAA0B,QAAqD;AAC7F,QAAM,UAAU;AAAA,IACd,SAAS,OAAO;AAAA,IAChB,UAAU,OAAO;AAAA,IACjB,YAAY,OAAO;AAAA,IACnB,YAAY,OAAO;AAAA,IACnB,QAAQ,OAAO;AAAA,IACf,SAAS,OAAO;AAAA,EAClB;AACA,SAAO;AAAA,IACL,SAAS;AAAA,IACT;AAAA,IACA,OAAO,OAAO,aAAa,UAAU,OAAO,WAAW,OAAO,WAAW,SAAS,SAAS;AAAA,IAC3F,QAAQ,cAAc,MAAM;AAAA,EAC9B;AACF;AAEO,SAAS,kCAAkC,UAG9C,CAAC,GAAG;AACN,QAAM,SAAS,QAAQ,UAAU;AACjC,SAAO,CAAC,WAAwD;AAC9D,UAAM,QAAQ,0BAA0B,MAAM;AAC9C,QAAI,QAAQ,SAAS;AACnB,cAAQ,QAAQ,OAAO,OAAO,IAAI,MAAM;AAAA,IAC1C;AACA,QAAI,MAAM,UAAU,QAAQ;AAC1B,UAAI,OAAO,OAAO,SAAS,YAAY;AACrC,eAAO,KAAK,MAAM,SAAS,MAAM,OAAO;AAAA,MAC1C,OAAO;AACL,YAAI,KAAK,MAAM,SAAS,MAAM,OAAO;AAAA,MACvC;AAAA,IACF,OAAO;AACL,UAAI,OAAO,OAAO,UAAU,YAAY;AACtC,eAAO,MAAM,MAAM,SAAS,MAAM,OAAO;AAAA,MAC3C,OAAO;AACL,YAAI,MAAM,MAAM,SAAS,MAAM,OAAO;AAAA,MACxC;AAAA,IACF;AACA,WAAO;AAAA,EACT;AACF;AAQA,IAAM,oCAAoC;AAwBnC,SAAS,mCAAmC,SAGxC;AACT,QAAM,aAAa,QAAQ;AAC3B,MAAI,CAAC,OAAO,SAAS,UAAU,KAAK,cAAc,EAAG,QAAO;AAC5D,QAAM,YAAY,QAAQ;AAC1B,MAAI,cAAc,QAAQ,CAAC,OAAO,SAAS,SAAS,EAAG,QAAO;AAC9D,MAAI,aAAa,EAAG,QAAO;AAC3B,SAAO,KAAK;AAAA,IACV;AAAA,IACA,KAAK,IAAI,GAAG,KAAK,MAAM,YAAY,iCAAiC,CAAC;AAAA,EACvE;AACF;AA4BA,eAAsB,+BAAkC,SAMX;AAC3C,QAAM,MAAM,QAAQ,OAAO,KAAK;AAChC,QAAM,cAAc,IAAI;AACxB,QAAM,aAAa,IAAI,gBAAgB;AACvC,QAAM,eAAe,QAAQ;AAC7B,QAAM,gBAAgB,MAAM,WAAW,MAAM;AAC7C,MAAI,cAAc,SAAS;AACzB,eAAW,MAAM;AAAA,EACnB,WAAW,cAAc;AACvB,iBAAa,iBAAiB,SAAS,eAAe,EAAE,MAAM,KAAK,CAAC;AAAA,EACtE;AAEA,QAAM,UAAU,OAAO,SAAS,QAAQ,UAAU,KAAK,QAAQ,aAAa;AAC5E,MAAI;AAEJ,MAAI;AAGF,UAAM,OAAO,QAAQ,IAAI,WAAW,MAAM,EAAE;AAAA,MAC1C,CAAC,WAAW,EAAE,MAAM,SAAkB,MAAM;AAAA,IAC9C;AACA,QAAI,CAAC,SAAS;AACZ,YAAMA,WAAU,MAAM;AACtB,aAAO,EAAE,OAAOA,SAAQ,OAAO,UAAU,OAAO,YAAY,IAAI,IAAI,YAAY;AAAA,IAClF;AACA,UAAM,WAAW,QAAQ,cAAmC;AAG5D,YAAQ,WAAW,MAAM,SAAS,QAAQ,EAAE,MAAM,UAAU,CAAC,GAAG,QAAQ,UAAU;AAClF,UAAM,UAAU,MAAM,QAAQ,KAAK,CAAC,MAAM,SAAS,OAAO,CAAC;AAC3D,QAAI,QAAQ,SAAS,WAAW;AAC9B,iBAAW,MAAM,WAAW,kCAAkC,CAAC;AAG/D,WAAK,KAAK,MAAM,MAAM;AAAA,MAAC,CAAC;AACxB,aAAO,EAAE,OAAO,QAAQ,UAAU,UAAU,MAAM,YAAY,IAAI,IAAI,YAAY;AAAA,IACpF;AACA,WAAO,EAAE,OAAO,QAAQ,OAAO,UAAU,OAAO,YAAY,IAAI,IAAI,YAAY;AAAA,EAClF,UAAE;AACA,iBAAa,KAAK;AAClB,kBAAc,oBAAoB,SAAS,aAAa;AAAA,EAC1D;AACF;AA0BO,SAAS,+BAA+B,SAY/B;AACd,QAAM,SAAS,QAAQ,UAAU;AACjC,QAAM,MAAM,QAAQ,OAAO,KAAK;AAChC,SAAO,OACL,SACA,UACA,QACe;AACf,UAAM,cAAc,IAAI;AACxB,UAAM,aAAa,mCAAmC;AAAA,MACpD,0BAA0B,QAAQ;AAAA,MAClC,kBACE,QAAQ,sBAAsB,OAAO,OAAO,QAAQ,oBAAoB;AAAA,IAC5E,CAAC;AACD,QAAI;AACJ,QAAI;AACF,gBAAU,MAAM,+BAA+B;AAAA,QAC7C;AAAA,QACA;AAAA,QACA,cAAc,QAAQ;AAAA,QACtB;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH,SAAS,KAAK;AACZ,UAAI,CAAC,aAAa,GAAG,EAAG,OAAM;AAC9B,YAAM,aAAa,IAAI,IAAI;AAC3B,cAAQ,OAAO;AAAA,QACb;AAAA,QACA,UAAU;AAAA,QACV;AAAA,QACA;AAAA,QACA,QAAQ;AAAA,QACR,SAAS;AAAA,QACT,QAAQ,aAAa,UAAU;AAAA,MACjC,CAAC;AACD,aAAO;AAAA,IACT;AACA,QAAI,QAAQ,UAAU;AACpB,aAAO;AAAA,QACL,mBAAmB,OAAO,kBAAkB,UAAU,0BAC3C,QAAQ,UAAU;AAAA,MAC/B;AAAA,IACF;AACA,YAAQ,OAAO;AAAA,MACb;AAAA,MACA,UAAU;AAAA,MACV,YAAY,QAAQ;AAAA,MACpB;AAAA,MACA,QAAQ,QAAQ,WAAW,YAAY;AAAA,MACvC,SAAS,CAAC,QAAQ;AAAA,IACpB,CAAC;AACD,WAAO,QAAQ;AAAA,EACjB;AACF;","names":["settled"]}

package/dist/{chunk-BDNL34CT.js → chunk-4WBGZYZZ.js}

@@ -1,3 +1,9 @@
+import {
+  checkEntityRecallAbort,
+  entityRecallSectionAbsent,
+  yieldEntityRecallScan,
+  yieldEntityRecallScanEvery
+} from "./chunk-5AUY5Z5E.js";
 import {
   containsPhrase
 } from "./chunk-SVH57F5Z.js";
@@ -6,7 +12,7 @@ import {
 } from "./chunk-2DQ2XREU.js";
 import {
   compareEntityTimestamps
-} from "./chunk-IDE5AR5W.js";
+} from "./chunk-PLCZD3LG.js";
 import {
   normalizeEntityName
 } from "./chunk-YXZG5TVN.js";
@@ -376,7 +382,8 @@ function hasFreshNativeExplicitMention(index, nativeChunks, query) {
   };
   return resolveLanguageIndependentExplicitCandidates(freshNativeIndex, query).length > 0;
 }
-async function buildEntityMentionIndex(storage, config, recallNamespaces, namespaceStorage, nativeChunksOverride, resolvedStorages) {
+async function buildEntityMentionIndex(storage, config, recallNamespaces, namespaceStorage, nativeChunksOverride, resolvedStorages, abortSignal) {
+  checkEntityRecallAbort(abortSignal);
   const storages = resolvedStorages ?? await resolveEntityIndexStorages(
     storage,
     config,
@@ -391,12 +398,16 @@ async function buildEntityMentionIndex(storage, config, recallNamespaces, namesp
     Promise.all(storages.map((scopedStorage) => scopedStorage.readAllMemories())),
     nativeChunksOverride ? Promise.resolve(nativeChunksOverride) : readNativeChunks(config, recallNamespaces)
   ]);
+  checkEntityRecallAbort(abortSignal);
   const entityRecords = entityFileSets.flatMap(
     (set, index2) => set.map((entity) => ({ entity, storage: storages[index2] }))
   );
   const memories = memorySets.flat();
+  let scanned = 0;
   const entities = /* @__PURE__ */ new Map();
   for (const { entity, storage: entityStorage } of entityRecords) {
+    scanned += 1;
+    await yieldEntityRecallScanEvery(scanned, abortSignal);
     const canonicalId = typeof entityStorage.normalizeEntityName === "function" ? entityStorage.normalizeEntityName(entity.name, entity.type) : normalizeEntityName(entity.name, entity.type, entityStorage.entityAliases);
     const rawStructuredSections = entity.structuredSections ?? [];
     const rawBeliefLedgerFactKeys = beliefLedgerFactKeys(rawStructuredSections);
@@ -423,7 +434,10 @@ async function buildEntityMentionIndex(storage, config, recallNamespaces, namesp
       nativeChunks: []
     });
   }
+  scanned = 0;
   for (const memory of memories) {
+    scanned += 1;
+    await yieldEntityRecallScanEvery(scanned, abortSignal);
     const entityRef = typeof memory.frontmatter.entityRef === "string" ? memory.frontmatter.entityRef : "";
     if (!entityRef) continue;
     const entry = entities.get(entityRef);
@@ -433,6 +447,7 @@ async function buildEntityMentionIndex(storage, config, recallNamespaces, namesp
       entry.memorySnippets.push(snippet);
     }
   }
+  await yieldEntityRecallScan(abortSignal);
   const aliasIndex = buildAliasIndex([...entities.values()]);
   for (const chunk of nativeChunks) {
     const existingPseudo = entities.get(nativePseudoCanonicalId(chunk));
@@ -452,8 +467,11 @@ async function buildEntityMentionIndex(storage, config, recallNamespaces, namesp
     const pseudoEntry = createPseudoNativeEntry(chunk);
     entities.set(pseudoEntry.canonicalId, pseudoEntry);
   }
+  await yieldEntityRecallScan(abortSignal);
   const sortedEntities = [...entities.values()].sort((left, right) => left.name.localeCompare(right.name));
+  await yieldEntityRecallScan(abortSignal);
   const previousEntities = previousIndex ? JSON.stringify(previousIndex.entities) : "";
+  await yieldEntityRecallScan(abortSignal);
   const nextEntities = JSON.stringify(sortedEntities);
   const entityStatusVersionAfter = shouldPersistIndex ? storage.getMemoryStatusVersion() : void 0;
   const canPersistIndex = shouldPersistIndex && entityStatusVersionBefore === entityStatusVersionAfter;
@@ -464,6 +482,7 @@ async function buildEntityMentionIndex(storage, config, recallNamespaces, namesp
     entities: sortedEntities
   };
   if (canPersistIndex) {
+    checkEntityRecallAbort(abortSignal);
     await writeEntityIndexState(storage, index);
   }
   return index;
@@ -769,6 +788,7 @@ function formatEntityHintSection(candidates, queryTokens, mode, maxRelatedEntiti
   return result.trim().length > 0 ? result.trimEnd() : null;
 }
 async function buildEntityRecallSection(options) {
+  checkEntityRecallAbort(options.abortSignal);
   const prefixedMode = detectEntityQueryMode(options.query);
   const persistedIndex = prefixedMode ? null : await readCurrentPersistedEntityIndex(
     options.storage,
@@ -776,11 +796,12 @@ async function buildEntityRecallSection(options) {
     options.recallNamespaces,
     options.namespaceStorage
   );
+  checkEntityRecallAbort(options.abortSignal);
   let nativeChunks;
   if (!prefixedMode && persistedIndex && resolveLanguageIndependentExplicitCandidates(persistedIndex, options.query).length === 0) {
     nativeChunks = await readNativeChunks(options.config, options.recallNamespaces);
     if (!hasFreshNativeExplicitMention(persistedIndex, nativeChunks, options.query)) {
-      return null;
+      return entityRecallSectionAbsent(options.abortSignal);
     }
   }
   const namespaceScoped = resolveNamespaceCapabilities(options.config).namespaces && options.namespaceStorage !== void 0 && (options.recallNamespaces?.length ?? 0) > 0;
@@ -799,6 +820,7 @@ async function buildEntityRecallSection(options) {
     nativeEntityIndexRevision(nativeChunks)
   ) : void 0;
   let index = namespaceCacheKey ? namespaceEntityIndexCache.get(namespaceCacheKey) : void 0;
+  checkEntityRecallAbort(options.abortSignal);
   if (!index) {
     index = await buildEntityMentionIndex(
       options.storage,
@@ -806,16 +828,19 @@ async function buildEntityRecallSection(options) {
       options.recallNamespaces,
       options.namespaceStorage,
       nativeChunks,
-      resolvedStorages
+      resolvedStorages,
+      options.abortSignal
     );
     if (namespaceCacheKey) rememberNamespaceEntityIndex(namespaceCacheKey, index);
   }
+  await yieldEntityRecallScan(options.abortSignal);
   const explicitCandidates = resolveExplicitCandidates(index, options.query);
+  await yieldEntityRecallScan(options.abortSignal);
   const queryCandidates = prefixedMode ? explicitCandidates : resolveLanguageIndependentExplicitCandidates(index, options.query);
   const mode = prefixedMode ?? (queryCandidates.length > 0 ? "direct" : null);
-  if (!mode) return null;
+  if (!mode) return entityRecallSectionAbsent(options.abortSignal);
   const candidates = queryCandidates.length > 0 ? queryCandidates : resolveRecentTurnCandidates(index, options.transcriptEntries, options.recentTurns);
-  if (candidates.length === 0) return null;
+  if (candidates.length === 0) return entityRecallSectionAbsent(options.abortSignal);
   const queryTokens = tokenize(options.query);
   const candidateLimit = queryCandidates.length === 0 && mode === "follow_up" ? 1 : options.maxHints;
   const rankedCandidates = candidates.slice(0, candidateLimit);
@@ -844,7 +869,7 @@ async function buildEntityRecallSection(options) {
     })
   );
   const section = formatEntityHintSection(enriched, queryTokens, mode, options.maxRelatedEntities, options.maxChars);
-  if (!section) return null;
+  if (!section) return entityRecallSectionAbsent(options.abortSignal);
   return section;
 }
 async function readRecentEntityTranscriptEntries(transcriptEntriesPromise, recentTurns) {
@@ -862,4 +887,4 @@ export {
   entityIndexVersion,
   entityRecentTranscriptLookbackHours
 };
-//# sourceMappingURL=chunk-BDNL34CT.js.map
+//# sourceMappingURL=chunk-4WBGZYZZ.js.map