@remnic/core 10.0.13 → 10.0.14

package/dist/{chunk-MZBWIJJN.js → chunk-63B2IZYE.js}

@@ -9,10 +9,21 @@ import {
   writeOfflineUploadChunk,
   writeSafeFileFromUpload
 } from "./chunk-3E6DGSGZ.js";
+import {
+  OFFLINE_SYNC_FAST_BASE_MTIME_TOLERANCE_MS,
+  SYNC_INTERNAL_DIR,
+  assertOfflineSyncMtimeMs,
+  isEncryptedOfflineSyncFile,
+  plainFileDigest,
+  readPlainOfflineSyncFileChunk,
+  setSafeFileMtime,
+  sha256OfflineSyncFile,
+  shouldExcludeOfflineSyncFile
+} from "./chunk-EFHNFTWB.js";
 import {
   applyChangesetEmbeddingGenerations,
   normalizeChangesetGenerations
-} from "./chunk-AAM66QCP.js";
+} from "./chunk-UZRSI6NX.js";
 import {
   applyIncomingEmbeddingGenerations,
   assertEmbeddingGenerationStillIncluded,
@@ -21,27 +32,16 @@ import {
   embeddingGenerationMembership,
   isEmbeddingGenerationDirPath,
   isPathInOmittedEmbeddingGeneration
-} from "./chunk-3NFN4Y4P.js";
-import {
-  isCanonicalRuntimeStatePath,
-  shouldDeleteAbsentIncomingOfflineRuntimeFile,
-  shouldPreferIncomingOfflineRuntimeFile
-} from "./chunk-TYT4TEQV.js";
+} from "./chunk-MGCKZWAE.js";
 import {
   isEmbeddingGenerationMarkerPath,
   matchesOfflineSyncDefaultExclude
 } from "./chunk-63LFM77Z.js";
 import {
-  OFFLINE_SYNC_FAST_BASE_MTIME_TOLERANCE_MS,
-  SYNC_INTERNAL_DIR,
-  assertOfflineSyncMtimeMs,
-  isEncryptedOfflineSyncFile,
-  plainFileDigest,
-  readPlainOfflineSyncFileChunk,
-  setSafeFileMtime,
-  sha256OfflineSyncFile,
-  shouldExcludeOfflineSyncFile
-} from "./chunk-EFHNFTWB.js";
+  isCanonicalRuntimeStatePath,
+  shouldDeleteAbsentIncomingOfflineRuntimeFile,
+  shouldPreferIncomingOfflineRuntimeFile
+} from "./chunk-TYT4TEQV.js";
 import {
   prepareSafeArchiveRoot,
   resolveSafeArchiveTarget,
@@ -51,7 +51,7 @@ import {
 import {
   withEmbeddingGenerationLock,
   withEmbeddingGenerationLockIter
-} from "./chunk-ZI7LMSNI.js";
+} from "./chunk-LLHZZOIB.js";
 import {
   CENSUS_MAX_MTIME_MS,
   isSha256Hex
@@ -1787,4 +1787,4 @@ export {
   normalizeOfflineSyncState,
   fileStatesFromSnapshot
 };
-//# sourceMappingURL=chunk-MZBWIJJN.js.map
+//# sourceMappingURL=chunk-63B2IZYE.js.map

package/dist/{chunk-DGRMWDQY.js → chunk-66BCOVW2.js}

@@ -1,6 +1,12 @@
 import {
   resolveEnsureCollectionArgs
 } from "./chunk-G26YNEOC.js";
+import {
+  QmdDaemonSession
+} from "./chunk-SWWHIJUJ.js";
+import {
+  createInflightJoiner
+} from "./chunk-TPSLVZHS.js";
 import {
   QMD_PROBE_RETRY_BACKOFF_MS,
   QMD_PROBE_TIMEOUT_MS,
@@ -19,12 +25,6 @@ import {
   embedQmdFiles,
   fetchQmdStatus
 } from "./chunk-IUM3VSHI.js";
-import {
-  QmdDaemonSession
-} from "./chunk-WVHRNAXL.js";
-import {
-  createInflightJoiner
-} from "./chunk-TPSLVZHS.js";
 import {
   clearQmdResultCaches,
   getCachedQmdSearch,
@@ -2028,4 +2028,4 @@ export {
   sharedDaemonSessionCountForTest,
   QmdClient
 };
-//# sourceMappingURL=chunk-DGRMWDQY.js.map
+//# sourceMappingURL=chunk-66BCOVW2.js.map

package/dist/chunk-6EDW54SQ.js

@@ -0,0 +1,298 @@
+import {
+  CAPTURE_WRITE_LOCK_BUSY_MESSAGE,
+  captureWriteLockDelayMs,
+  resolveCaptureWriteLockBackoffLimits
+} from "./chunk-YET735EZ.js";
+import {
+  withHeldFileLock
+} from "./chunk-5B5WYAHQ.js";
+import {
+  sleepAbortable
+} from "./chunk-PGRZ3FYC.js";
+import {
+  raceAbort,
+  throwIfAborted
+} from "./chunk-BTTPKDIL.js";
+import {
+  log
+} from "./chunk-3WCASNQZ.js";
+
+// src/storage/tombstone-blocked-capture-mutation.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { createHash } from "crypto";
+import { mkdir } from "fs/promises";
+import path from "path";
+var TOMBSTONE_CAPTURE_WRITE_LOCK_STALE_MS = 6e4;
+var CAPTURE_WRITE_LOCK_PROBE_MS = 1;
+var CAPTURE_WRITE_LOCK_RETRY = /* @__PURE__ */ Symbol("capture-write-lock-retry");
+var CAPTURE_WRITE_LOCK_PERMANENT = /* @__PURE__ */ Symbol("capture-write-lock-permanent-failure");
+function normalizeExplicitCaptureContent(value) {
+  return value.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function buildExplicitCaptureDedupKey(content, category, sourceConnector) {
+  const encode = (label, value) => `${label} ${value.length} ${value}`;
+  return [
+    encode("category", category),
+    encode("connector", sourceConnector?.trim() ?? ""),
+    encode("content", normalizeExplicitCaptureContent(content))
+  ].join(" ");
+}
+function buildCapturePathLockIdentity(pathname) {
+  return `path ${pathname.length} ${pathname}`;
+}
+function captureIdentityHash(memory) {
+  return createHash("sha256").update(
+    buildExplicitCaptureDedupKey(memory.content, memory.frontmatter.category, memory.frontmatter.sourceConnector)
+  ).digest("hex");
+}
+var TombstoneBlockedCaptureWriteLock = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  context = new AsyncLocalStorage();
+  captureWriteLockPathForHash(identityHash) {
+    const filename = identityHash.length === 0 ? "explicit-capture-write.lock" : `explicit-capture-write-${identityHash}.lock`;
+    return path.join(this.options.stateDir, "tombstone-blocked-capture", filename);
+  }
+  now() {
+    return this.options.now?.() ?? Date.now();
+  }
+  debug(message) {
+    if (this.options.logDebug) {
+      this.options.logDebug(message);
+      return;
+    }
+    log.debug(message);
+  }
+  warn(message) {
+    if (this.options.logWarn) {
+      this.options.logWarn(message);
+      return;
+    }
+    log.warn(message);
+  }
+  /** Prefer the constructor seam; converge installs the signal on lock options at acquire time. */
+  captureAbortSignal() {
+    return this.options.signal ?? this.options.lockOptions?.()?.captureWriteLockSignal;
+  }
+  /**
+   * One probe of a single lock file. Returns the retry symbol when the lock
+   * is busy and the permanent symbol on a filesystem error. Does not sleep:
+   * the caller backs off only after the whole chain has unwound.
+   */
+  async withSingleCaptureWriteLockOnce(lockPath, task) {
+    await mkdir(path.dirname(lockPath), { recursive: true });
+    const runWithHeldFileLock = this.options.withHeldFileLock ?? withHeldFileLock;
+    return await runWithHeldFileLock(
+      lockPath,
+      {
+        staleMs: TOMBSTONE_CAPTURE_WRITE_LOCK_STALE_MS,
+        maxWaitMs: CAPTURE_WRITE_LOCK_PROBE_MS,
+        pollMs: CAPTURE_WRITE_LOCK_PROBE_MS
+      },
+      async (acquired, controller) => {
+        if (acquired) return await task();
+        return controller.failure === "error" ? CAPTURE_WRITE_LOCK_PERMANENT : CAPTURE_WRITE_LOCK_RETRY;
+      }
+    );
+  }
+  async withPhysicalCaptureWriteLocks(task, identityHashes) {
+    const signal = this.captureAbortSignal();
+    const lockPaths = [...new Set(identityHashes.map((hash) => this.captureWriteLockPathForHash(hash)))];
+    const limits = resolveCaptureWriteLockBackoffLimits(this.options.lockOptions?.());
+    const deadline = this.now() + limits.deadlineMs;
+    const giveUp = () => {
+      throwIfAborted(signal);
+      this.warn(
+        `tombstone-blocked capture write lock remained busy after ${limits.deadlineMs}ms; failing this write so the rest of the cycle can continue`
+      );
+      throw new Error(CAPTURE_WRITE_LOCK_BUSY_MESSAGE);
+    };
+    const acquire = async (index) => {
+      throwIfAborted(signal);
+      const runTask = async () => {
+        if (this.now() >= deadline) giveUp();
+        return await task();
+      };
+      if (index === lockPaths.length) return await runTask();
+      const lockPath = lockPaths[index];
+      if (lockPath === void 0) return await runTask();
+      if (this.now() >= deadline) giveUp();
+      return await this.withSingleCaptureWriteLockOnce(lockPath, () => acquire(index + 1));
+    };
+    for (let attempt = 0; ; attempt += 1) {
+      throwIfAborted(signal);
+      const outcome = await acquire(0);
+      if (outcome === CAPTURE_WRITE_LOCK_PERMANENT) {
+        throw new Error("tombstone-blocked capture write lock acquisition failed");
+      }
+      if (outcome !== CAPTURE_WRITE_LOCK_RETRY) return outcome;
+      throwIfAborted(signal);
+      const now = this.now();
+      if (now >= deadline) giveUp();
+      const delay = Math.min(
+        captureWriteLockDelayMs(attempt, limits, this.options.random ?? Math.random),
+        deadline - now
+      );
+      if (delay <= 0) giveUp();
+      this.debug(`tombstone-blocked capture write lock busy; backing off ${delay}ms before retry ${attempt + 1}`);
+      await raceAbort((this.options.sleep ?? sleepAbortable)(delay, signal), signal);
+    }
+  }
+  async withCaptureWriteLock(task, identity) {
+    const identities = Array.isArray(identity) && identity.length > 0 ? identity : [typeof identity === "string" ? identity : ""];
+    return await this.withCaptureWriteLocks(task, identities, []);
+  }
+  async withCaptureWriteLockHashes(task, identityHashes) {
+    return await this.withCaptureWriteLocks(task, [], identityHashes);
+  }
+  async withCaptureWriteLockAndHashes(task, identity, identityHashes) {
+    const identities = Array.isArray(identity) && identity.length > 0 ? identity : [typeof identity === "string" ? identity : ""];
+    return await this.withCaptureWriteLocks(task, identities, identityHashes);
+  }
+  async withCaptureWriteLocks(task, identities, identityHashes) {
+    throwIfAborted(this.captureAbortSignal());
+    const current = this.context.getStore();
+    const hashToken = (key) => `\0${key.length === 0 ? "" : createHash("sha256").update(key).digest("hex")}`;
+    const identityHash = (key) => key.length === 0 ? "" : createHash("sha256").update(key).digest("hex");
+    const identityKeys = [...new Set(identities)];
+    const hashes = [...new Set(identityHashes)];
+    const requested = [
+      ...identityKeys.filter((key) => !current || !current.has(key) && !current.has(hashToken(key))).map((key) => ({ hash: identityHash(key), pathLock: key.startsWith("path ") })),
+      ...hashes.filter((hash) => !current || !current.has(`\0${hash}`)).map((hash) => ({ hash, pathLock: false }))
+    ].filter((entry, index, entries) => entries.findIndex((candidate) => candidate.hash === entry.hash) === index).sort(
+      (left, right) => Number(left.pathLock) - Number(right.pathLock) || this.captureWriteLockPathForHash(left.hash).localeCompare(this.captureWriteLockPathForHash(right.hash))
+    );
+    const physicalMissing = requested.map((entry) => entry.hash);
+    if (current && requested.length > 0) {
+      const held = [...current].filter((token) => token.startsWith("\0")).map((token) => {
+        const hash = token.slice(1);
+        const pathLock = [...current].some(
+          (key) => !key.startsWith("\0") && key.startsWith("path ") && hashToken(key) === token
+        );
+        return { hash, pathLock };
+      });
+      const requestedFirst = requested[0];
+      const heldLast = held.sort(
+        (left, right) => Number(left.pathLock) - Number(right.pathLock) || this.captureWriteLockPathForHash(left.hash).localeCompare(this.captureWriteLockPathForHash(right.hash))
+      ).at(-1);
+      if (heldLast && requestedFirst && (Number(requestedFirst.pathLock) < Number(heldLast.pathLock) || requestedFirst.pathLock === heldLast.pathLock && this.captureWriteLockPathForHash(requestedFirst.hash) < this.captureWriteLockPathForHash(heldLast.hash))) {
+        throw new Error(CAPTURE_WRITE_LOCK_BUSY_MESSAGE);
+      }
+    }
+    const next = new Set(current);
+    for (const key of identityKeys) {
+      next.add(key);
+      next.add(hashToken(key));
+    }
+    for (const hash of hashes) next.add(`\0${hash}`);
+    const run = () => {
+      throwIfAborted(this.captureAbortSignal());
+      return this.context.run(next, task);
+    };
+    if (physicalMissing.length === 0) return await run();
+    return await this.withPhysicalCaptureWriteLocks(run, physicalMissing);
+  }
+};
+async function runTombstoneBlockedMutation(host, mutation) {
+  let lockIdentity = mutation.identity;
+  for (; ; ) {
+    let retryIdentity;
+    let mintedRevision;
+    const mutate = async () => {
+      const current = await host.readCurrent();
+      const currentBlocked = host.isBlocked(current);
+      const currentQueuedReview = host.isQueuedReview(current);
+      if (current !== null && (mutation.coordinate === true || currentBlocked || currentQueuedReview)) {
+        const currentIdentity = host.memoryIdentity(current);
+        const heldIdentities = Array.isArray(lockIdentity) ? lockIdentity : [lockIdentity];
+        if (!heldIdentities.includes(currentIdentity)) {
+          retryIdentity = currentIdentity;
+          return;
+        }
+      }
+      const rebuildMarker = mutation.blocked || currentBlocked ? await host.prepareWrite() : void 0;
+      const discardRebuildMarker = async () => {
+        if (!rebuildMarker) return;
+        try {
+          await host.discardWrite(rebuildMarker);
+        } catch (cleanupError) {
+          host.markUntrusted();
+          host.logWarning(`storage.tombstoneBlocked failed to clear write marker: ${cleanupError}`);
+        }
+      };
+      let transaction;
+      try {
+        transaction = mutation.shouldMintRevision?.(current) ? await host.beginDurableMemoryRevision?.(mutation.pathname, mutation.fileContent) : void 0;
+        await host.writeStorageSecureFile(mutation.pathname, mutation.fileContent);
+      } catch (err) {
+        if (transaction) {
+          try {
+            await transaction.abort();
+          } catch (abortError) {
+            host.logWarning(
+              `storage.tombstoneBlocked failed to abort the reserved receipt (pending marker preserved): ${abortError}`
+            );
+          }
+        }
+        await discardRebuildMarker();
+        throw err;
+      }
+      if (transaction) {
+        try {
+          await transaction.writeLanded();
+        } catch (evidenceError) {
+          host.logWarning(
+            `storage.tombstoneBlocked failed to record receipt crash evidence (pending marker preserved): ${evidenceError}`
+          );
+        }
+        try {
+          await transaction.commit();
+        } catch (err) {
+          host.logWarning(
+            `storage.tombstoneBlocked receipt publication failed after the memory write (pending marker preserved for recovery): ${err}`
+          );
+          await discardRebuildMarker();
+          throw err;
+        }
+      }
+      mintedRevision = transaction?.pendingRevision;
+      if (rebuildMarker) {
+        try {
+          await host.commitWrite(rebuildMarker);
+        } catch (err) {
+          host.markUntrusted();
+          host.logWarning(`storage.tombstoneBlocked committed write marker failed: ${err}`);
+        }
+      }
+      if (rebuildMarker) await mutation.beforeIndexUpdate?.();
+      await mutation.updateIndex(rebuildMarker, currentBlocked && current !== null ? current : void 0);
+    };
+    await host.withCaptureWriteLock(mutate, lockIdentity);
+    if (retryIdentity === void 0) return mintedRevision;
+    const identities = Array.isArray(lockIdentity) ? [...lockIdentity, retryIdentity] : [lockIdentity, retryIdentity];
+    lockIdentity = [...new Set(identities)];
+  }
+}
+function tombstoneBlocked(frontmatter) {
+  return frontmatter.status === "pending_review" && Boolean(frontmatter.blockedBy);
+}
+function isQueuedReviewFrontmatter(frontmatter) {
+  return frontmatter.status === "pending_review" && (frontmatter.tags ?? []).includes("queued-review");
+}
+function isQueuedReviewMemory(memory) {
+  return memory !== null && isQueuedReviewFrontmatter(memory.frontmatter);
+}
+
+export {
+  normalizeExplicitCaptureContent,
+  buildExplicitCaptureDedupKey,
+  buildCapturePathLockIdentity,
+  captureIdentityHash,
+  TombstoneBlockedCaptureWriteLock,
+  runTombstoneBlockedMutation,
+  tombstoneBlocked,
+  isQueuedReviewMemory
+};
+//# sourceMappingURL=chunk-6EDW54SQ.js.map

package/dist/chunk-6EDW54SQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/storage/tombstone-blocked-capture-mutation.ts"],"sourcesContent":["import { AsyncLocalStorage } from \"node:async_hooks\";\nimport { createHash } from \"node:crypto\";\nimport { mkdir } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { raceAbort, throwIfAborted } from \"../abort-error.js\";\nimport {\n  CAPTURE_WRITE_LOCK_BUSY_MESSAGE,\n  type CaptureWriteLockLimitSource,\n  captureWriteLockDelayMs,\n  resolveCaptureWriteLockBackoffLimits,\n} from \"../capture-write-lock-backoff.js\";\nimport { log } from \"../logger.js\";\nimport type { MemoryFile, MemoryFrontmatter } from \"../types.js\";\nimport { withHeldFileLock } from \"../utils/serialize-mutations.js\";\nimport { sleepAbortable } from \"../utils/sleep.js\";\nimport type { CasRevisionTransaction } from \"./cas-revision-store.js\";\n\nexport { isTombstoneBlockedCaptureWriteLockBusy } from \"../capture-write-lock-backoff.js\";\n\nconst TOMBSTONE_CAPTURE_WRITE_LOCK_STALE_MS = 60_000;\n/**\n * One exclusive-create probe. The bounded wait lives in the outer backoff,\n * which runs only after every lock from this attempt has been released.\n * A multi-second poll here would hold an already-acquired sibling lock.\n */\nconst CAPTURE_WRITE_LOCK_PROBE_MS = 1;\nconst CAPTURE_WRITE_LOCK_RETRY = Symbol(\"capture-write-lock-retry\");\nconst CAPTURE_WRITE_LOCK_PERMANENT = Symbol(\"capture-write-lock-permanent-failure\");\n\nexport function normalizeExplicitCaptureContent(value: string): string {\n  return value.toLowerCase().replace(/\\s+/g, \" \").trim();\n}\n\nexport function buildExplicitCaptureDedupKey(\n  content: string,\n  category: string,\n  sourceConnector: string | undefined\n): string {\n  const encode = (label: string, value: string): string => `${label} ${value.length} ${value}`;\n  return [\n    encode(\"category\", category),\n    encode(\"connector\", sourceConnector?.trim() ?? \"\"),\n    encode(\"content\", normalizeExplicitCaptureContent(content)),\n  ].join(\" \");\n}\n\nexport function buildCapturePathLockIdentity(pathname: string): string {\n  return `path ${pathname.length} ${pathname}`;\n}\n\nexport function captureIdentityHash(memory: MemoryFile): string {\n  return createHash(\"sha256\")\n    .update(\n      buildExplicitCaptureDedupKey(memory.content, memory.frontmatter.category, memory.frontmatter.sourceConnector)\n    )\n    .digest(\"hex\");\n}\n\nexport type TombstoneBlockedCaptureWriteLockOptions = {\n  readonly stateDir: string;\n  readonly withHeldFileLock?: typeof withHeldFileLock;\n  /** Read when an acquire starts, after the caller has installed converge config. */\n  readonly lockOptions?: () => CaptureWriteLockLimitSource | undefined;\n  readonly now?: () => number;\n  readonly random?: () => number;\n  readonly sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;\n  readonly logDebug?: (message: string) => void;\n  readonly logWarn?: (message: string) => void;\n  /** Direct seam. Converge passes the same signal through `lockOptions` instead. */\n  readonly signal?: AbortSignal;\n};\n\nexport class TombstoneBlockedCaptureWriteLock {\n  private readonly context = new AsyncLocalStorage<ReadonlySet<string>>();\n\n  constructor(private readonly options: TombstoneBlockedCaptureWriteLockOptions) {}\n\n  private captureWriteLockPathForHash(identityHash: string): string {\n    const filename =\n      identityHash.length === 0 ? \"explicit-capture-write.lock\" : `explicit-capture-write-${identityHash}.lock`;\n    return path.join(this.options.stateDir, \"tombstone-blocked-capture\", filename);\n  }\n\n  private now(): number {\n    return this.options.now?.() ?? Date.now();\n  }\n\n  private debug(message: string): void {\n    if (this.options.logDebug) {\n      this.options.logDebug(message);\n      return;\n    }\n    log.debug(message);\n  }\n\n  private warn(message: string): void {\n    if (this.options.logWarn) {\n      this.options.logWarn(message);\n      return;\n    }\n    log.warn(message);\n  }\n\n  /** Prefer the constructor seam; converge installs the signal on lock options at acquire time. */\n  private captureAbortSignal(): AbortSignal | undefined {\n    return this.options.signal ?? this.options.lockOptions?.()?.captureWriteLockSignal;\n  }\n\n  /**\n   * One probe of a single lock file. Returns the retry symbol when the lock\n   * is busy and the permanent symbol on a filesystem error. Does not sleep:\n   * the caller backs off only after the whole chain has unwound.\n   */\n  private async withSingleCaptureWriteLockOnce<T>(\n    lockPath: string,\n    task: () => Promise<T | typeof CAPTURE_WRITE_LOCK_RETRY>\n  ): Promise<T | typeof CAPTURE_WRITE_LOCK_RETRY | typeof CAPTURE_WRITE_LOCK_PERMANENT> {\n    await mkdir(path.dirname(lockPath), { recursive: true });\n    const runWithHeldFileLock = this.options.withHeldFileLock ?? withHeldFileLock;\n    return await runWithHeldFileLock(\n      lockPath,\n      {\n        staleMs: TOMBSTONE_CAPTURE_WRITE_LOCK_STALE_MS,\n        maxWaitMs: CAPTURE_WRITE_LOCK_PROBE_MS,\n        pollMs: CAPTURE_WRITE_LOCK_PROBE_MS,\n      },\n      async (acquired, controller) => {\n        if (acquired) return await task();\n        return controller.failure === \"error\" ? CAPTURE_WRITE_LOCK_PERMANENT : CAPTURE_WRITE_LOCK_RETRY;\n      }\n    );\n  }\n\n  private async withPhysicalCaptureWriteLocks<T>(\n    task: () => Promise<T>,\n    identityHashes: readonly string[]\n  ): Promise<T> {\n    const signal = this.captureAbortSignal();\n    const lockPaths = [...new Set(identityHashes.map((hash) => this.captureWriteLockPathForHash(hash)))];\n    const limits = resolveCaptureWriteLockBackoffLimits(this.options.lockOptions?.());\n    const deadline = this.now() + limits.deadlineMs;\n    const giveUp = (): never => {\n      throwIfAborted(signal);\n      this.warn(\n        `tombstone-blocked capture write lock remained busy after ${limits.deadlineMs}ms; failing this write so the rest of the cycle can continue`\n      );\n      throw new Error(CAPTURE_WRITE_LOCK_BUSY_MESSAGE);\n    };\n    const acquire = async (\n      index: number\n    ): Promise<T | typeof CAPTURE_WRITE_LOCK_RETRY | typeof CAPTURE_WRITE_LOCK_PERMANENT> => {\n      throwIfAborted(signal);\n      // The deadline gates each probe: a chain that started before the\n      // deadline must not keep probing locks (or run the write) after it.\n      const runTask = async (): Promise<T> => {\n        if (this.now() >= deadline) giveUp();\n        return await task();\n      };\n      if (index === lockPaths.length) return await runTask();\n      const lockPath = lockPaths[index];\n      if (lockPath === undefined) return await runTask();\n      if (this.now() >= deadline) giveUp();\n      return await this.withSingleCaptureWriteLockOnce(lockPath, () => acquire(index + 1));\n    };\n    for (let attempt = 0; ; attempt += 1) {\n      throwIfAborted(signal);\n      const outcome = await acquire(0);\n      if (outcome === CAPTURE_WRITE_LOCK_PERMANENT) {\n        throw new Error(\"tombstone-blocked capture write lock acquisition failed\");\n      }\n      if (outcome !== CAPTURE_WRITE_LOCK_RETRY) return outcome;\n      throwIfAborted(signal);\n      const now = this.now();\n      if (now >= deadline) giveUp();\n      const delay = Math.min(\n        captureWriteLockDelayMs(attempt, limits, this.options.random ?? Math.random),\n        deadline - now\n      );\n      if (delay <= 0) giveUp();\n      this.debug(`tombstone-blocked capture write lock busy; backing off ${delay}ms before retry ${attempt + 1}`);\n      // raceAbort covers seam sleeps that ignore the signal; the default\n      // sleepAbortable also clears its timer so abort holds no Timeout.\n      await raceAbort((this.options.sleep ?? sleepAbortable)(delay, signal), signal);\n    }\n  }\n\n  async withCaptureWriteLock<T>(task: () => Promise<T>, identity?: string | readonly string[]): Promise<T> {\n    const identities =\n      Array.isArray(identity) && identity.length > 0 ? identity : [typeof identity === \"string\" ? identity : \"\"];\n    return await this.withCaptureWriteLocks(task, identities, []);\n  }\n\n  async withCaptureWriteLockHashes<T>(task: () => Promise<T>, identityHashes: readonly string[]): Promise<T> {\n    return await this.withCaptureWriteLocks(task, [], identityHashes);\n  }\n\n  async withCaptureWriteLockAndHashes<T>(\n    task: () => Promise<T>,\n    identity: string | readonly string[] | undefined,\n    identityHashes: readonly string[]\n  ): Promise<T> {\n    const identities =\n      Array.isArray(identity) && identity.length > 0 ? identity : [typeof identity === \"string\" ? identity : \"\"];\n    return await this.withCaptureWriteLocks(task, identities, identityHashes);\n  }\n\n  private async withCaptureWriteLocks<T>(\n    task: () => Promise<T>,\n    identities: readonly string[],\n    identityHashes: readonly string[]\n  ): Promise<T> {\n    throwIfAborted(this.captureAbortSignal());\n    const current = this.context.getStore();\n    const hashToken = (key: string): string =>\n      `\\u0000${key.length === 0 ? \"\" : createHash(\"sha256\").update(key).digest(\"hex\")}`;\n    const identityHash = (key: string): string =>\n      key.length === 0 ? \"\" : createHash(\"sha256\").update(key).digest(\"hex\");\n    const identityKeys = [...new Set(identities)];\n    const hashes = [...new Set(identityHashes)];\n    const requested = [\n      ...identityKeys\n        .filter((key) => !current || (!current.has(key) && !current.has(hashToken(key))))\n        .map((key) => ({ hash: identityHash(key), pathLock: key.startsWith(\"path \") })),\n      ...hashes.filter((hash) => !current || !current.has(`\\u0000${hash}`)).map((hash) => ({ hash, pathLock: false })),\n    ]\n      .filter((entry, index, entries) => entries.findIndex((candidate) => candidate.hash === entry.hash) === index)\n      .sort(\n        (left, right) =>\n          Number(left.pathLock) - Number(right.pathLock) ||\n          this.captureWriteLockPathForHash(left.hash).localeCompare(this.captureWriteLockPathForHash(right.hash))\n      );\n    const physicalMissing = requested.map((entry) => entry.hash);\n    if (current && requested.length > 0) {\n      const held = [...current]\n        .filter((token) => token.startsWith(\"\\u0000\"))\n        .map((token) => {\n          const hash = token.slice(1);\n          const pathLock = [...current].some(\n            (key) => !key.startsWith(\"\\u0000\") && key.startsWith(\"path \") && hashToken(key) === token\n          );\n          return { hash, pathLock };\n        });\n      const requestedFirst = requested[0];\n      const heldLast = held\n        .sort(\n          (left, right) =>\n            Number(left.pathLock) - Number(right.pathLock) ||\n            this.captureWriteLockPathForHash(left.hash).localeCompare(this.captureWriteLockPathForHash(right.hash))\n        )\n        .at(-1);\n      if (\n        heldLast &&\n        requestedFirst &&\n        (Number(requestedFirst.pathLock) < Number(heldLast.pathLock) ||\n          (requestedFirst.pathLock === heldLast.pathLock &&\n            this.captureWriteLockPathForHash(requestedFirst.hash) < this.captureWriteLockPathForHash(heldLast.hash)))\n      ) {\n        throw new Error(CAPTURE_WRITE_LOCK_BUSY_MESSAGE);\n      }\n    }\n    const next = new Set(current);\n    for (const key of identityKeys) {\n      next.add(key);\n      next.add(hashToken(key));\n    }\n    for (const hash of hashes) next.add(`\\u0000${hash}`);\n    const run = () => {\n      throwIfAborted(this.captureAbortSignal());\n      return this.context.run(next, task);\n    };\n    if (physicalMissing.length === 0) return await run();\n    return await this.withPhysicalCaptureWriteLocks(run, physicalMissing);\n  }\n}\n\nexport type TombstoneBlockedMutationHost = {\n  readCurrent: () => Promise<MemoryFile | null>;\n  isBlocked: (memory: MemoryFile | null) => boolean;\n  isQueuedReview: (memory: MemoryFile | null) => boolean;\n  memoryIdentity: (memory: MemoryFile) => string;\n  prepareWrite: () => Promise<string>;\n  commitWrite: (marker: string) => Promise<void>;\n  discardWrite: (marker: string) => Promise<void>;\n  markUntrusted: () => void;\n  writeStorageSecureFile: (pathname: string, fileContent: string) => Promise<void>;\n  withCaptureWriteLock: (task: () => Promise<void>, identity: string | readonly string[]) => Promise<void>;\n  logWarning: (message: string) => void;\n  beginDurableMemoryRevision?: (\n    pathname: string,\n    expectedContent?: string | Buffer | null\n  ) => Promise<CasRevisionTransaction | undefined>;\n};\n\nexport type TombstoneBlockedMutation = {\n  blocked: boolean;\n  pathname: string;\n  fileContent: string;\n  identity: string | readonly string[];\n  updateIndex: (rebuildMarker?: string, current?: MemoryFile | null) => Promise<void>;\n  beforeIndexUpdate?: () => Promise<void>;\n  coordinate?: boolean;\n  shouldMintRevision?: (current: MemoryFile | null) => boolean;\n};\n\nexport async function runTombstoneBlockedMutation(\n  host: TombstoneBlockedMutationHost,\n  mutation: TombstoneBlockedMutation\n): Promise<string | undefined> {\n  let lockIdentity: string | readonly string[] = mutation.identity;\n  for (;;) {\n    let retryIdentity: string | undefined;\n    let mintedRevision: string | undefined;\n    const mutate = async (): Promise<void> => {\n      const current = await host.readCurrent();\n      const currentBlocked = host.isBlocked(current);\n      const currentQueuedReview = host.isQueuedReview(current);\n      if (current !== null && (mutation.coordinate === true || currentBlocked || currentQueuedReview)) {\n        const currentIdentity = host.memoryIdentity(current);\n        const heldIdentities = Array.isArray(lockIdentity) ? lockIdentity : [lockIdentity];\n        if (!heldIdentities.includes(currentIdentity)) {\n          retryIdentity = currentIdentity;\n          return;\n        }\n      }\n      const rebuildMarker = mutation.blocked || currentBlocked ? await host.prepareWrite() : undefined;\n      const discardRebuildMarker = async (): Promise<void> => {\n        if (!rebuildMarker) return;\n        try {\n          await host.discardWrite(rebuildMarker);\n        } catch (cleanupError) {\n          host.markUntrusted();\n          host.logWarning(`storage.tombstoneBlocked failed to clear write marker: ${cleanupError}`);\n        }\n      };\n      let transaction: CasRevisionTransaction | undefined;\n      try {\n        // #2813 (P1 C): a two-phase receipt transaction under this same\n        // path lock. The PENDING reservation is minted BEFORE the durable\n        // file publish, so a failed reservation leaves the memory file\n        // untouched — never a mutated record without a receipt. The\n        // COMMITTED receipt publishes only AFTER the write lands, so a\n        // failed write can never leave the reservation posing as\n        // ownership.\n        transaction = mutation.shouldMintRevision?.(current)\n          ? await host.beginDurableMemoryRevision?.(mutation.pathname, mutation.fileContent)\n          : undefined;\n        await host.writeStorageSecureFile(mutation.pathname, mutation.fileContent);\n      } catch (err) {\n        // The memory write failed (or never ran): abort the reservation so\n        // no pending marker survives a write that did not land. A failed\n        // abort keeps the marker — ambiguity, recovered later.\n        if (transaction) {\n          try {\n            await transaction.abort();\n          } catch (abortError) {\n            host.logWarning(\n              `storage.tombstoneBlocked failed to abort the reserved receipt (pending marker preserved): ${abortError}`\n            );\n          }\n        }\n        await discardRebuildMarker();\n        throw err;\n      }\n      if (transaction) {\n        // #2807: record the post-write fingerprint in the PENDING marker\n        // BEFORE publishing, so a crash between the durable write and the\n        // COMMITTED receipt is decisively recoverable. The evidence only\n        // guards that crash window — a recording failure must not fail the\n        // landed write, so commit still runs and publishes truthfully.\n        try {\n          await transaction.writeLanded();\n        } catch (evidenceError) {\n          host.logWarning(\n            `storage.tombstoneBlocked failed to record receipt crash evidence (pending marker preserved): ${evidenceError}`\n          );\n        }\n        try {\n          await transaction.commit();\n        } catch (err) {\n          // #2813 (P1 C): the memory file LANDED but the COMMITTED receipt\n          // never published. The PENDING marker stays: readers must see\n          // unavailable/recovery-needed — never ownership, never absence —\n          // and promotion/rollback refuse until recovery reconciles. The\n          // reservation must NOT be aborted: the write is on disk.\n          host.logWarning(\n            `storage.tombstoneBlocked receipt publication failed after the memory write (pending marker preserved for recovery): ${err}`\n          );\n          await discardRebuildMarker();\n          throw err;\n        }\n      }\n      mintedRevision = transaction?.pendingRevision;\n      if (rebuildMarker) {\n        try {\n          await host.commitWrite(rebuildMarker);\n        } catch (err) {\n          host.markUntrusted();\n          host.logWarning(`storage.tombstoneBlocked committed write marker failed: ${err}`);\n        }\n      }\n      if (rebuildMarker) await mutation.beforeIndexUpdate?.();\n      await mutation.updateIndex(rebuildMarker, currentBlocked && current !== null ? current : undefined);\n    };\n\n    await host.withCaptureWriteLock(mutate, lockIdentity);\n    if (retryIdentity === undefined) return mintedRevision;\n    const identities = Array.isArray(lockIdentity) ? [...lockIdentity, retryIdentity] : [lockIdentity, retryIdentity];\n    lockIdentity = [...new Set(identities)];\n  }\n}\n\nexport function tombstoneBlocked(frontmatter: MemoryFrontmatter): boolean {\n  return frontmatter.status === \"pending_review\" && Boolean(frontmatter.blockedBy);\n}\n\nexport function isQueuedReviewFrontmatter(frontmatter: MemoryFrontmatter): boolean {\n  return frontmatter.status === \"pending_review\" && (frontmatter.tags ?? []).includes(\"queued-review\");\n}\n\nexport function isQueuedReviewMemory(memory: MemoryFile | null): memory is MemoryFile {\n  return memory !== null && isQueuedReviewFrontmatter(memory.frontmatter);\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-P2S6P7X6.js → chunk-6LG7BWKW.js}

@@ -1,7 +1,7 @@
 import {
   canonicalCategoryForAlias,
   categoryAliasCoercion
-} from "./chunk-CBP4HWCL.js";
+} from "./chunk-W5MCEVUS.js";
 
 // src/access-observe-write-category.ts
 function splitCanonicalWriteRequest(request) {
@@ -22,4 +22,4 @@ function splitCanonicalWriteRequest(request) {
 export {
   splitCanonicalWriteRequest
 };
-//# sourceMappingURL=chunk-P2S6P7X6.js.map
+//# sourceMappingURL=chunk-6LG7BWKW.js.map

package/dist/chunk-77R7BQZ2.js

@@ -0,0 +1,152 @@
+import {
+  GROUNDING_MIN_SHARED_TOKENS,
+  areGroundingTokensCompatible,
+  entityNameStart,
+  hasDenialReporting,
+  hasNonAssertiveReporting,
+  isGroundedEntityName,
+  normalizedEntityIdentifierTokens,
+  sourceSentences,
+  tokenize
+} from "./chunk-AIYXVWUH.js";
+
+// src/extraction-quote-grounding.ts
+var QUOTE_ANCHOR_MIN_CHARS = 12;
+var QUOTE_ANCHOR_CONTEXT_CHARS = 400;
+var QUOTE_ANCHOR_MIN_WINDOW_COVERAGE = 0.35;
+var QUOTE_ANCHOR_MIN_SOURCE_COVERAGE = 0.75;
+var QUOTE_ANCHOR_MAX_OCCURRENCES = 8;
+var TURN_SEPARATOR = "\n\n";
+var NEGATOR_PATTERN = /\b(?:not|no|never|cannot|without|neither|nor)\b|n't\b/iu;
+var EXCLUSION_PATTERN = /\b(?:exclu\w*|avoid\w*|omit\w*|skip\w*|ignor\w*|forbid\w*|prohibit\w*|disallow\w*|prevent\w*|reject\w*|refus\w*|insufficient|instead|rather|unless|except)\b/iu;
+function normalizeWhitespaceWithMap(source) {
+  const chars = [];
+  const originalIndex = [];
+  let inSpace = false;
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index];
+    if (/\s/u.test(char)) {
+      if (inSpace) continue;
+      inSpace = true;
+      chars.push(" ");
+    } else {
+      inSpace = false;
+      chars.push(char);
+    }
+    originalIndex.push(index);
+  }
+  return { text: chars.join(""), originalIndex };
+}
+function findQuoteAnchors(quote, source) {
+  const needle = quote.replace(/\s+/gu, " ").trim();
+  if (needle.length < QUOTE_ANCHOR_MIN_CHARS) return [];
+  const normalized = normalizeWhitespaceWithMap(source);
+  const anchors = [];
+  let from = 0;
+  while (anchors.length < QUOTE_ANCHOR_MAX_OCCURRENCES) {
+    const at = normalized.text.indexOf(needle, from);
+    if (at < 0) break;
+    from = at + 1;
+    const start = normalized.originalIndex[at];
+    const end = normalized.originalIndex[at + needle.length - 1] + 1;
+    if (source.slice(start, end).includes(TURN_SEPARATOR)) continue;
+    let before = source.slice(Math.max(0, start - QUOTE_ANCHOR_CONTEXT_CHARS), start);
+    const turnStart = before.lastIndexOf(TURN_SEPARATOR);
+    if (turnStart >= 0) before = before.slice(turnStart + TURN_SEPARATOR.length);
+    else if (start > QUOTE_ANCHOR_CONTEXT_CHARS) before = before.replace(/^\S+/u, "");
+    let after = source.slice(end, end + QUOTE_ANCHOR_CONTEXT_CHARS);
+    const turnEnd = after.indexOf(TURN_SEPARATOR);
+    if (turnEnd >= 0) after = after.slice(0, turnEnd);
+    else if (source.length - end > QUOTE_ANCHOR_CONTEXT_CHARS) after = after.replace(/\S+$/u, "");
+    anchors.push({ quote: needle, window: `${before}${needle.replace(/;/gu, ",")}${after}` });
+  }
+  return anchors;
+}
+function quoteAnchors(quote, source, transformQuote) {
+  if (typeof quote !== "string") return [];
+  const exact = findQuoteAnchors(quote, source);
+  if (exact.length > 0 || transformQuote === void 0) return exact;
+  return findQuoteAnchors(transformQuote(quote), source);
+}
+function tokenPool(tokens) {
+  const list = [...tokens];
+  return (token) => tokens.has(token) || list.some((poolToken) => areGroundingTokensCompatible(token, poolToken));
+}
+function hasNegation(text) {
+  return NEGATOR_PATTERN.test(text.replace(/[\u2018\u2019]/gu, "'")) || hasDenialReporting(text);
+}
+function misstatesQuote(content, quote) {
+  const keepsNegation = hasNegation(content) || EXCLUSION_PATTERN.test(content);
+  const keepsReporting = hasNonAssertiveReporting(content) || content.trim().endsWith("?");
+  const contentHas = tokenPool(tokenize(content));
+  return (quote.match(/[^;.!?\n]+[;.!?]*/gu) ?? []).some((clause) => {
+    const negated = hasNegation(clause) && !keepsNegation;
+    const unasserted = (clause.trim().endsWith("?") || hasNonAssertiveReporting(clause)) && !keepsReporting;
+    if (!negated && !unasserted) return false;
+    const clauseTokens = [...tokenize(clause)];
+    const shared = clauseTokens.filter(contentHas).length;
+    return shared >= GROUNDING_MIN_SHARED_TOKENS && shared / clauseTokens.length >= 0.5;
+  });
+}
+function isQuoteAnchoredClaim(content, anchor, sourceHas) {
+  const contentTokens = [...tokenize(content)];
+  if (contentTokens.length === 0) return false;
+  const quoteHas = tokenPool(tokenize(anchor.quote));
+  if (contentTokens.filter(quoteHas).length < GROUNDING_MIN_SHARED_TOKENS) return false;
+  const windowHas = tokenPool(tokenize(anchor.window));
+  if (contentTokens.filter(windowHas).length / contentTokens.length < QUOTE_ANCHOR_MIN_WINDOW_COVERAGE) {
+    return false;
+  }
+  return contentTokens.filter(sourceHas).length / contentTokens.length >= QUOTE_ANCHOR_MIN_SOURCE_COVERAGE && !misstatesQuote(content, anchor.quote);
+}
+function filterEntityFacts(entity, isSupported) {
+  const facts = entity.facts.filter(isSupported);
+  const structuredSections = entity.structuredSections?.flatMap((section) => {
+    const groundedFacts = section.facts.filter(isSupported);
+    return groundedFacts.length > 0 ? [{ ...section, facts: groundedFacts }] : [];
+  });
+  if (facts.length === 0 && (structuredSections === void 0 || structuredSections.length === 0)) {
+    return void 0;
+  }
+  const { structuredSections: _structuredSections, ...entityWithoutSections } = entity;
+  return {
+    ...entityWithoutSections,
+    facts,
+    ...structuredSections && structuredSections.length > 0 ? { structuredSections } : {}
+  };
+}
+function quoteAnchoredEntitySupport(entity, anchors, sourceHas) {
+  const nameAnchors = anchors.filter((anchor) => isGroundedEntityName(entity.name, anchor.window));
+  if (nameAnchors.length === 0) return void 0;
+  return (fact) => nameAnchors.some((anchor) => isQuoteAnchoredClaim(fact, anchor, sourceHas));
+}
+function isQuoteAnchoredRelationship(relationship, anchors, sourceHas) {
+  const labelTokens = [...tokenize(relationship.label)];
+  if (labelTokens.length === 0) return false;
+  const relationText = [
+    normalizedEntityIdentifierTokens(relationship.source).join(" "),
+    relationship.label,
+    normalizedEntityIdentifierTokens(relationship.target).join(" ")
+  ].join(" ");
+  return anchors.some((anchor) => {
+    const windowHas = tokenPool(tokenize(anchor.window));
+    return labelTokens.every(windowHas) && sourceSentences(anchor.window).some((sentence) => {
+      const sourceStart = entityNameStart(relationship.source, sentence);
+      return sourceStart >= 0 && entityNameStart(relationship.target, sentence) > sourceStart;
+    }) && isQuoteAnchoredClaim(relationText, anchor, sourceHas);
+  });
+}
+
+export {
+  QUOTE_ANCHOR_MIN_CHARS,
+  QUOTE_ANCHOR_CONTEXT_CHARS,
+  QUOTE_ANCHOR_MIN_WINDOW_COVERAGE,
+  QUOTE_ANCHOR_MIN_SOURCE_COVERAGE,
+  quoteAnchors,
+  tokenPool,
+  isQuoteAnchoredClaim,
+  filterEntityFacts,
+  quoteAnchoredEntitySupport,
+  isQuoteAnchoredRelationship
+};
+//# sourceMappingURL=chunk-77R7BQZ2.js.map

package/dist/chunk-77R7BQZ2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/extraction-quote-grounding.ts"],"sourcesContent":["/**\n * Quote-anchored source grounding.\n *\n * An extracted fact carries the exact words that support it in `quote`. A quote\n * that is a verbatim substring of the source (whitespace-normalized) is real\n * evidence: the claim only has to be supported by the text around that span,\n * not by word overlap against the whole conversation. Items without such a\n * quote never get an anchor here and stay on the whole-source rules.\n */\n\nimport type { ExtractionResult } from \"./types.js\";\nimport {\n  GROUNDING_MIN_SHARED_TOKENS,\n  areGroundingTokensCompatible,\n  entityNameStart,\n  hasDenialReporting,\n  hasNonAssertiveReporting,\n  isGroundedEntityName,\n  normalizedEntityIdentifierTokens,\n  sourceSentences,\n  tokenize,\n} from \"./extraction-source-grounding-helpers.js\";\n\n/** Shortest normalized quote that counts as evidence; \"the\" or \"I\" prove nothing. */\nexport const QUOTE_ANCHOR_MIN_CHARS = 12;\n/** Characters of context kept on each side of the quote inside its turn. */\nexport const QUOTE_ANCHOR_CONTEXT_CHARS = 400;\n/** Share of a claim's content words that must occur in the quote's window. */\nexport const QUOTE_ANCHOR_MIN_WINDOW_COVERAGE = 0.35;\n/** Share of a claim's content words that must occur anywhere in the source; the rest is invented. */\nexport const QUOTE_ANCHOR_MIN_SOURCE_COVERAGE = 0.75;\nconst QUOTE_ANCHOR_MAX_OCCURRENCES = 8;\nconst TURN_SEPARATOR = \"\\n\\n\";\nconst NEGATOR_PATTERN = /\\b(?:not|no|never|cannot|without|neither|nor)\\b|n't\\b/iu;\nconst EXCLUSION_PATTERN =\n  /\\b(?:exclu\\w*|avoid\\w*|omit\\w*|skip\\w*|ignor\\w*|forbid\\w*|prohibit\\w*|disallow\\w*|prevent\\w*|reject\\w*|refus\\w*|insufficient|instead|rather|unless|except)\\b/iu;\n\n/** A verbatim quote and the text around it inside its turn. */\nexport interface QuoteAnchor {\n  /** Whitespace-normalized quote, exactly as it appears in the source. */\n  quote: string;\n  /** `quote` with its turn-local context; `;` inside the quote is rewritten to `,`. */\n  window: string;\n}\n\nexport type TokenPool = (token: string) => boolean;\n\ntype Entity = ExtractionResult[\"entities\"][number];\ntype Relationship = NonNullable<ExtractionResult[\"relationships\"]>[number];\n\nfunction normalizeWhitespaceWithMap(source: string): { text: string; originalIndex: number[] } {\n  const chars: string[] = [];\n  const originalIndex: number[] = [];\n  let inSpace = false;\n  for (let index = 0; index < source.length; index += 1) {\n    const char = source[index]!;\n    if (/\\s/u.test(char)) {\n      if (inSpace) continue;\n      inSpace = true;\n      chars.push(\" \");\n    } else {\n      inSpace = false;\n      chars.push(char);\n    }\n    originalIndex.push(index);\n  }\n  return { text: chars.join(\"\"), originalIndex };\n}\n\nfunction findQuoteAnchors(quote: string, source: string): QuoteAnchor[] {\n  const needle = quote.replace(/\\s+/gu, \" \").trim();\n  if (needle.length < QUOTE_ANCHOR_MIN_CHARS) return [];\n  const normalized = normalizeWhitespaceWithMap(source);\n  const anchors: QuoteAnchor[] = [];\n  let from = 0;\n  while (anchors.length < QUOTE_ANCHOR_MAX_OCCURRENCES) {\n    const at = normalized.text.indexOf(needle, from);\n    if (at < 0) break;\n    from = at + 1;\n    const start = normalized.originalIndex[at]!;\n    const end = normalized.originalIndex[at + needle.length - 1]! + 1;\n    if (source.slice(start, end).includes(TURN_SEPARATOR)) continue;\n\n    let before = source.slice(Math.max(0, start - QUOTE_ANCHOR_CONTEXT_CHARS), start);\n    const turnStart = before.lastIndexOf(TURN_SEPARATOR);\n    if (turnStart >= 0) before = before.slice(turnStart + TURN_SEPARATOR.length);\n    else if (start > QUOTE_ANCHOR_CONTEXT_CHARS) before = before.replace(/^\\S+/u, \"\");\n\n    let after = source.slice(end, end + QUOTE_ANCHOR_CONTEXT_CHARS);\n    const turnEnd = after.indexOf(TURN_SEPARATOR);\n    if (turnEnd >= 0) after = after.slice(0, turnEnd);\n    else if (source.length - end > QUOTE_ANCHOR_CONTEXT_CHARS) after = after.replace(/\\S+$/u, \"\");\n\n    anchors.push({ quote: needle, window: `${before}${needle.replace(/;/gu, \",\")}${after}` });\n  }\n  return anchors;\n}\n\n/**\n * Returns one anchor per place `quote` occurs verbatim in `source`, or [] when\n * the quote is absent, too short, or not an exact substring. A quote that\n * spans a turn separator is not one turn's words and yields no anchor; windows\n * never extend past their turn.\n *\n * The quote is one evidence unit: a `;` inside it is rewritten to `,` in the\n * window so sentence splitting cannot cut it, or a claim that merges two of\n * its clauses could never be grounded in a single sentence.\n *\n * `source` may have been rewritten before grounding (temporal anchoring,\n * pronoun resolution) while the model quoted the original words. When the raw\n * quote is not found, `transformQuote` applies the same rewrite to the quote.\n */\nexport function quoteAnchors(\n  quote: string | undefined,\n  source: string,\n  transformQuote?: (quote: string) => string,\n): QuoteAnchor[] {\n  if (typeof quote !== \"string\") return [];\n  const exact = findQuoteAnchors(quote, source);\n  if (exact.length > 0 || transformQuote === undefined) return exact;\n  return findQuoteAnchors(transformQuote(quote), source);\n}\n\nexport function tokenPool(tokens: ReadonlySet<string>): TokenPool {\n  const list = [...tokens];\n  return (token) => tokens.has(token) || list.some((poolToken) => areGroundingTokensCompatible(token, poolToken));\n}\n\nfunction hasNegation(text: string): boolean {\n  return NEGATOR_PATTERN.test(text.replace(/[\\u2018\\u2019]/gu, \"'\")) || hasDenialReporting(text);\n}\n\n/**\n * True when the claim asserts what a quote clause denies or does not assert:\n * \"did not approve the budget\" or \"denied approving it\" restated as \"approved\n * the budget\", \"suspects Bob stole funds\" or \"Is Alice the CEO?\" restated as a\n * plain statement. A claim that keeps a negator, exclusion word, or reporting\n * marker (\"do not X\" reworded as \"X is excluded\") is not a misstatement.\n */\nfunction misstatesQuote(content: string, quote: string): boolean {\n  const keepsNegation = hasNegation(content) || EXCLUSION_PATTERN.test(content);\n  const keepsReporting = hasNonAssertiveReporting(content) || content.trim().endsWith(\"?\");\n  const contentHas = tokenPool(tokenize(content));\n  return (quote.match(/[^;.!?\\n]+[;.!?]*/gu) ?? []).some((clause) => {\n    const negated = hasNegation(clause) && !keepsNegation;\n    const unasserted = (clause.trim().endsWith(\"?\") || hasNonAssertiveReporting(clause)) && !keepsReporting;\n    if (!negated && !unasserted) return false;\n    const clauseTokens = [...tokenize(clause)];\n    const shared = clauseTokens.filter(contentHas).length;\n    return shared >= GROUNDING_MIN_SHARED_TOKENS && shared / clauseTokens.length >= 0.5;\n  });\n}\n\n/**\n * A claim is supported by a verbatim quote when it shares at least\n * GROUNDING_MIN_SHARED_TOKENS content words with the quote, a good part of its\n * words sit in the text around the quote, nearly all of them occur in the\n * source at all, and it does not invert a negated clause of the quote. Reworded\n * and lightly elaborated claims pass; claims that bring words the conversation\n * never used, or that have nothing to do with the quote, do not.\n */\nexport function isQuoteAnchoredClaim(content: string, anchor: QuoteAnchor, sourceHas: TokenPool): boolean {\n  const contentTokens = [...tokenize(content)];\n  if (contentTokens.length === 0) return false;\n  const quoteHas = tokenPool(tokenize(anchor.quote));\n  if (contentTokens.filter(quoteHas).length < GROUNDING_MIN_SHARED_TOKENS) return false;\n  const windowHas = tokenPool(tokenize(anchor.window));\n  if (contentTokens.filter(windowHas).length / contentTokens.length < QUOTE_ANCHOR_MIN_WINDOW_COVERAGE) {\n    return false;\n  }\n  return contentTokens.filter(sourceHas).length / contentTokens.length >= QUOTE_ANCHOR_MIN_SOURCE_COVERAGE\n    && !misstatesQuote(content, anchor.quote);\n}\n\n/** Keeps the entity facts (flat and sectioned) `isSupported` accepts; undefined when none remain. */\nexport function filterEntityFacts(entity: Entity, isSupported: (fact: string) => boolean): Entity | undefined {\n  const facts = entity.facts.filter(isSupported);\n  const structuredSections = entity.structuredSections?.flatMap((section) => {\n    const groundedFacts = section.facts.filter(isSupported);\n    return groundedFacts.length > 0 ? [{ ...section, facts: groundedFacts }] : [];\n  });\n  if (facts.length === 0 && (structuredSections === undefined || structuredSections.length === 0)) {\n    return undefined;\n  }\n  const { structuredSections: _structuredSections, ...entityWithoutSections } = entity;\n  return {\n    ...entityWithoutSections,\n    facts,\n    ...(structuredSections && structuredSections.length > 0 ? { structuredSections } : {}),\n  };\n}\n\n/**\n * Entities carry no quote of their own; the anchors of facts that kept support\n * them. Returns a fact predicate, or undefined when no anchor window names the entity.\n */\nexport function quoteAnchoredEntitySupport(\n  entity: Entity,\n  anchors: readonly QuoteAnchor[],\n  sourceHas: TokenPool,\n): ((fact: string) => boolean) | undefined {\n  const nameAnchors = anchors.filter((anchor) => isGroundedEntityName(entity.name, anchor.window));\n  if (nameAnchors.length === 0) return undefined;\n  return (fact) => nameAnchors.some((anchor) => isQuoteAnchoredClaim(fact, anchor, sourceHas));\n}\n\n/**\n * The label words and both names must sit in one anchor-window sentence, source\n * before target, so an invented label or a reversed edge never passes.\n */\nexport function isQuoteAnchoredRelationship(\n  relationship: Relationship,\n  anchors: readonly QuoteAnchor[],\n  sourceHas: TokenPool,\n): boolean {\n  const labelTokens = [...tokenize(relationship.label)];\n  if (labelTokens.length === 0) return false;\n  const relationText = [\n    normalizedEntityIdentifierTokens(relationship.source).join(\" \"),\n    relationship.label,\n    normalizedEntityIdentifierTokens(relationship.target).join(\" \"),\n  ].join(\" \");\n  return anchors.some((anchor) => {\n    const windowHas = tokenPool(tokenize(anchor.window));\n    return labelTokens.every(windowHas)\n      && sourceSentences(anchor.window).some((sentence) => {\n        const sourceStart = entityNameStart(relationship.source, sentence);\n        return sourceStart >= 0 && entityNameStart(relationship.target, sentence) > sourceStart;\n      })\n      && isQuoteAnchoredClaim(relationText, anchor, sourceHas);\n  });\n}\n"],"mappings":"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","names":[]}