@remnic/core 9.43.0 → 9.45.0

package/dist/{chunk-BEQOZOYZ.js → chunk-RVLJEII5.js}

@@ -1,3 +1,7 @@
+import {
+  CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS,
+  ContentHashIndex
+} from "./chunk-S5SLVSVY.js";
 import {
   markProjectedMemoryPathInvalid
 } from "./chunk-3CSX3ETE.js";
@@ -9,14 +13,7 @@ import {
   withHeldFileLock
 } from "./chunk-FFAZ2XFU.js";
 import {
-  computeContentHash,
-  normalizeContent
-} from "./chunk-W5H6ZRPT.js";
-import {
-  SecureStoreLockedError,
-  readMaybeEncryptedFile,
   readMaybeEncryptedFileFromChunks,
-  writeMaybeEncryptedFile,
   writeMaybeEncryptedFileFromChunks
 } from "./chunk-5TFP4CUL.js";
 import {
@@ -29,486 +26,11 @@ import {
   log
 } from "./chunk-3WCASNQZ.js";
 
-// src/storage/content-hash-index.ts
-import { mkdir, stat } from "fs/promises";
-import path from "path";
-var CONTENT_HASH_INDEX_LOCK_STALE_MS = 3e4;
-var CONTENT_HASH_INDEX_RETRY_MAX_ATTEMPTS = 5;
-var CONTENT_HASH_INDEX_RETRY_BASE_MS = 500;
-var CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS = 5e3;
-var FactHashIndexNotAuthoritativeError = class extends Error {
-  constructor(stateDir) {
-    super(
-      `fact-hash index is not authoritative: the cross-process rebuild lock for ${stateDir} could not be acquired within the bounded retry budget`
-    );
-    this.name = "FactHashIndexNotAuthoritativeError";
-  }
-};
-var ContentHashIndex = class _ContentHashIndex {
-  hashes = /* @__PURE__ */ new Set();
-  dirty = false;
-  /**
-   * Hashes explicitly removed since the last successful save (issue #1909 review
-   * round 8 thread 3). Tracked separately so `saveMergingWithDisk` can be
-   * removal-AWARE: under the file lock it reads the latest on-disk set, DROPS
-   * these, then unions our additions — so a removal batch cannot resurrect a
-   * hash (union alone would) and cannot clobber a concurrent extraction's
-   * appended hash (blind overwrite would). Consumed + cleared by every save.
-   */
-  removed = /* @__PURE__ */ new Set();
-  /**
-   * Hashes added by THIS instance since the last successful save (issue #1909
-   * review round 9 finding 3). Tracked separately from the loaded snapshot so a
-   * reconciling save publishes `(on-disk \ removed) ∪ added` — it re-applies only
-   * OUR additions, never the stale loaded entries. Without this, seeding the
-   * merge from `this.hashes` (loaded ∪ added) would resurrect a hash a peer
-   * removed on disk while this instance held a stale snapshot.
-   */
-  added = /* @__PURE__ */ new Set();
-  filePath;
-  secureStoreKeyProvider;
-  secureStoreWriteKeyProvider;
-  memoryDir;
-  lockOptions;
-  /**
-   * Deferred reconcile-save durable-retry state (issue #1909 / PR #2016). At
-   * most ONE retry is ever armed (`reconcileRetryTimer` is the reentrancy guard)
-   * so successive timed-out saves cannot stack duplicate/parallel retries.
-   * `reconcileRetryBarrier` resolves when the chain settles (published or gave
-   * up) — awaited by tests and any caller wanting the eventual result.
-   */
-  reconcileRetryTimer = null;
-  reconcileRetryAttempts = 0;
-  reconcileRetryBarrier = null;
-  reconcileRetryResolve = null;
-  /**
-   * On-disk fingerprint captured at the last point THIS instance's in-memory
-   * set matched disk — after `load()`, `save()`, or a reconcile publish. A peer
-   * process that advances the durable index changes its file generation even
-   * when byte size and mtime collide, so the freshness check remains safe
-   * without an O(file-size) read on the hot path.
-   */
-  lastSyncedFingerprint = null;
-  constructor(stateDir, secureStoreKeyProvider = () => null, secureStoreWriteKeyProvider = secureStoreKeyProvider, memoryDir = path.dirname(stateDir), lockOptions = {}) {
-    this.filePath = path.join(stateDir, "fact-hashes.txt");
-    this.secureStoreKeyProvider = secureStoreKeyProvider;
-    this.secureStoreWriteKeyProvider = secureStoreWriteKeyProvider;
-    this.memoryDir = memoryDir;
-    this.lockOptions = lockOptions;
-  }
-  /** Load existing hashes from disk. Safe to call multiple times. */
-  async load() {
-    try {
-      const raw = await readMaybeEncryptedFile(this.filePath, this.secureStoreKeyProvider(), this.memoryDir);
-      for (const line of raw.split("\n")) {
-        const trimmed = line.trim();
-        if (trimmed.length > 0) {
-          this.hashes.add(trimmed);
-        }
-      }
-      log.debug(`content-hash index: loaded ${this.hashes.size} hashes`);
-    } catch (err) {
-      if (err instanceof SecureStoreLockedError) throw err;
-      if (!isErrnoCode(err, "ENOENT")) throw err;
-      log.debug("content-hash index: no existing index \u2014 starting fresh");
-    }
-    await this.captureSyncedFingerprint();
-  }
-  /** Cheap `stat` of the durable index file; null when it does not exist yet. */
-  async statIndexFile() {
-    try {
-      const s = await stat(this.filePath);
-      return {
-        mtimeMs: s.mtimeMs,
-        size: s.size,
-        dev: s.dev,
-        ino: s.ino,
-        ctimeMs: s.ctimeMs,
-        birthtimeMs: s.birthtimeMs
-      };
-    } catch (err) {
-      if (isErrnoCode(err, "ENOENT")) return null;
-      throw err;
-    }
-  }
-  /** Record the current on-disk fingerprint as this instance's synced baseline. */
-  async captureSyncedFingerprint() {
-    try {
-      this.lastSyncedFingerprint = await this.statIndexFile();
-    } catch (err) {
-      this.lastSyncedFingerprint = null;
-      log.debug(`content-hash index: could not fingerprint ${this.filePath}: ${err}`);
-    }
-  }
-  /**
-   * True when the durable index file is unchanged since this instance last
-   * synced it (load / save / reconcile). False when a peer advanced it, when
-   * the file appeared or vanished, or when freshness cannot be established
-   * (stat error) — the caller then treats the in-memory snapshot as
-   * non-authoritative and confirms a dedup miss against the durable corpus.
-   * The stat includes file identity and generation metadata so same-size,
-   * same-mtime atomic replacements are detected without reading the file body.
-   */
-  async isDiskFingerprintCurrent() {
-    let current;
-    try {
-      current = await this.statIndexFile();
-    } catch {
-      return false;
-    }
-    const last = this.lastSyncedFingerprint;
-    if (last === null || current === null) {
-      return last === null && current === null;
-    }
-    return current.mtimeMs === last.mtimeMs && current.size === last.size && current.dev === last.dev && current.ino === last.ino && current.ctimeMs === last.ctimeMs && current.birthtimeMs === last.birthtimeMs;
-  }
-  /** Check if content already exists in the index. */
-  has(content) {
-    return this.hashes.has(_ContentHashIndex.computeHash(content));
-  }
-  /** Add content hash to the index. */
-  add(content) {
-    const hash = _ContentHashIndex.computeHash(content);
-    this.removed.delete(hash);
-    this.hashes.add(hash);
-    this.added.add(hash);
-    this.dirty = true;
-  }
-  get size() {
-    return this.hashes.size;
-  }
-  /** Clear all loaded hashes so the next save rewrites the index from scratch. */
-  clear() {
-    if (this.hashes.size > 0) {
-      this.hashes.clear();
-    }
-    this.added.clear();
-    this.removed.clear();
-    this.cancelReconcileRetry();
-    this.dirty = true;
-  }
-  /** Persist index to disk if changed (plain whole-file overwrite). */
-  async save() {
-    if (!this.dirty) return;
-    await mkdir(path.dirname(this.filePath), { recursive: true });
-    const publishedAdded = new Set(this.added);
-    const publishedRemoved = new Set(this.removed);
-    const serialized = [...this.hashes].join("\n") + "\n";
-    await writeMaybeEncryptedFile(
-      this.filePath,
-      serialized,
-      this.secureStoreWriteKeyProvider(),
-      {},
-      this.memoryDir
-    );
-    for (const h of publishedAdded) this.added.delete(h);
-    for (const h of publishedRemoved) this.removed.delete(h);
-    this.dirty = this.added.size > 0 || this.removed.size > 0;
-    await this.captureSyncedFingerprint();
-    if (this.dirty) {
-      this.scheduleReconcileRetry();
-    } else {
-      this.cancelReconcileRetry();
-    }
-    log.debug(`content-hash index: saved ${this.hashes.size} hashes`);
-  }
-  /**
-   * Persist the index by RECONCILING with the latest on-disk state under a
-   * cross-process lock (issue #1909). Used by the extraction-persist batch save
-   * for BOTH append and removal batches, so appends and removals to the same
-   * index serialize against each other:
-   *   final = (on-disk \ this.removed) ∪ this.added
-   * Note it re-applies only OUR local additions (`added`), NOT the loaded
-   * snapshot (review round 9 finding 3): seeding from `this.hashes` would
-   * resurrect a hash a peer removed on disk while we held a stale snapshot. This
-   * preserves a concurrent writer's appended hashes (a blind overwrite would
-   * drop them), never resurrects a removed hash, and never loses our additions.
-   *
-   * Hardening:
-   *  - Dirty short-circuit (round 7 finding 3): when this instance neither added
-   *    nor removed anything this run, skip the O(file) read+rewrite entirely.
-   *  - Cross-process lock (round 7 finding 2): serialize the read→reconcile→write
-   *    window on a per-file advisory lock. If the lock is NOT acquired (timeout),
-   *    do NOT publish (round 9 finding 2): keep `dirty` set AND schedule a bounded
-   *    durable background retry (PR #2016) that keeps re-attempting the locked
-   *    publish until the deferred additions land — never an unlocked write that
-   *    could clobber a peer, and never a silent "batch save complete" that leaves
-   *    the addition in this process's memory only.
-   */
-  async saveMergingWithDisk() {
-    if (!this.dirty) return;
-    await mkdir(path.dirname(this.filePath), { recursive: true });
-    const publish = async () => {
-      const publishedAdded = new Set(this.added);
-      const publishedRemoved = new Set(this.removed);
-      const merged = new Set(publishedAdded);
-      try {
-        const raw = await readMaybeEncryptedFile(
-          this.filePath,
-          this.secureStoreKeyProvider(),
-          this.memoryDir
-        );
-        for (const line of raw.split("\n")) {
-          const trimmed = line.trim();
-          if (trimmed.length > 0 && !publishedRemoved.has(trimmed)) merged.add(trimmed);
-        }
-      } catch (err) {
-        if (err instanceof SecureStoreLockedError) throw err;
-        if (!isErrnoCode(err, "ENOENT")) throw err;
-      }
-      await mkdir(path.dirname(this.filePath), { recursive: true });
-      await writeMaybeEncryptedFile(
-        this.filePath,
-        [...merged].join("\n") + "\n",
-        this.secureStoreWriteKeyProvider(),
-        {},
-        this.memoryDir
-      );
-      for (const h of publishedAdded) this.added.delete(h);
-      for (const h of publishedRemoved) this.removed.delete(h);
-      for (const h of this.added) merged.add(h);
-      for (const h of this.removed) merged.delete(h);
-      this.hashes = merged;
-      this.dirty = this.added.size > 0 || this.removed.size > 0;
-      await this.captureSyncedFingerprint();
-    };
-    await withHeldFileLock(
-      `${this.filePath}.lock`,
-      {
-        staleMs: CONTENT_HASH_INDEX_LOCK_STALE_MS,
-        ...this.lockOptions.maxWaitMs !== void 0 ? { maxWaitMs: this.lockOptions.maxWaitMs } : {},
-        ...this.lockOptions.pollMs !== void 0 ? { pollMs: this.lockOptions.pollMs } : {}
-      },
-      async (acquired) => {
-        if (!acquired) {
-          log.warn(
-            `content-hash index: lock not acquired for ${this.filePath}; deferring reconcile save (dirty retained, scheduling durable retry)`
-          );
-          this.scheduleReconcileRetry();
-          return;
-        }
-        await publish();
-        if (this.dirty) {
-          this.scheduleReconcileRetry();
-        } else {
-          this.cancelReconcileRetry();
-        }
-      }
-    );
-    log.debug(`content-hash index: reconcile-saved ${this.hashes.size} hashes`);
-  }
-  /**
-   * Rebuild-and-publish the index from an authoritative source (the durable
-   * corpus) under the SAME per-file cross-process lock the reconciling
-   * append/removal saves (`saveMergingWithDisk`) use (issue #1909 / PR #2016).
-   * The `populate` callback runs WHILE the lock is held and MUST repopulate this
-   * index from the corpus (`clear()` then `addByHash(...)` for every corpus
-   * hash); the rebuilt set is then published with a plain overwrite that is now
-   * serialized against every locked writer.
-   *
-   * This closes the finding where the previous unlocked clear→scan→save() could
-   * overwrite a peer's newer lock-merged or deferred additions: a locked writer
-   * that committed BEFORE the rebuild acquired the lock has its memory `.md` on
-   * disk and is re-scanned; one that commits AFTER the rebuild releases
-   * reconciles its additions on top of the freshly-published set. No union with
-   * the raw on-disk file is performed, so the rebuild keeps its
-   * garbage-collection property (orphaned hashes for deleted memories drop).
-   *
-   * Lock-acquisition failure is explicit and non-destructive: `populate` is NOT
-   * run and nothing is written (never an unlocked overwrite). Returns true when
-   * the rebuild was published under the lock, false when the lock timed out —
-   * the caller keeps the index non-authoritative and retries on next use. Uses
-   * the same non-reentrant file lock as the reconcile path, so it can never
-   * deadlock with the deferred reconcile-retry: a concurrent locked writer (or a
-   * fired retry) simply yields `acquired=false` after the bounded wait.
-   */
-  async rebuildUnderLock(populate) {
-    await mkdir(path.dirname(this.filePath), { recursive: true });
-    let published = false;
-    await withHeldFileLock(
-      `${this.filePath}.lock`,
-      {
-        staleMs: CONTENT_HASH_INDEX_LOCK_STALE_MS,
-        ...this.lockOptions.maxWaitMs !== void 0 ? { maxWaitMs: this.lockOptions.maxWaitMs } : {},
-        ...this.lockOptions.pollMs !== void 0 ? { pollMs: this.lockOptions.pollMs } : {}
-      },
-      async (acquired) => {
-        if (!acquired) {
-          log.warn(
-            `content-hash index: lock not acquired for ${this.filePath}; deferring authoritative rebuild (index left non-authoritative, retried on next use)`
-          );
-          return;
-        }
-        await populate();
-        await this.save();
-        published = true;
-      }
-    );
-    return published;
-  }
-  /**
-   * True while a background durable reconcile-save retry is armed (PR #2016).
-   * Test/introspection hook.
-   */
-  get hasPendingReconcileRetry() {
-    return this.reconcileRetryTimer !== null;
-  }
-  /** True while this index has in-memory changes not yet published to disk. */
-  get hasPendingChanges() {
-    return this.dirty;
-  }
-  /**
-   * Resolve once any armed background reconcile-save retry chain has settled —
-   * either it published the deferred additions, or it exhausted its bounded
-   * attempts and fell back to the corpus-rebuild safety net. Resolves
-   * immediately when nothing is armed. Lets a caller (or a test) await the
-   * eventual durability outcome of a lock-timed-out save.
-   */
-  async whenReconcileRetrySettled() {
-    await (this.reconcileRetryBarrier ?? Promise.resolve());
-  }
-  /**
-   * Drive any deferred lock-timeout reconcile save to completion INLINE at a
-   * lifecycle boundary (PR #2016 finding 3). The background retry timer is
-   * `unref`'d so it never keeps a long-lived daemon alive — but a short-lived
-   * writer (a one-shot CLI) can exit before it fires, leaving a durable fact
-   * `.md` whose hash never reached `fact-hashes.txt` for peers that already
-   * built their in-memory index. `orchestrator.destroy()` calls this so the
-   * addition publishes before the process exits; long-lived hosts only reach it
-   * at their own shutdown, so their in-flight retries keep running in the
-   * background until then. Bounded by the same attempt ceiling as the background
-   * retry; a permanently contended lock falls back to the corpus-rebuild-on-
-   * restart safety net (the fact `.md` is already durable). No deadlock: each
-   * attempt is the same non-reentrant, bounded-wait file lock.
-   */
-  async flushReconcileRetry() {
-    if (!this.dirty) return;
-    const maxAttempts = this.lockOptions.retryMaxAttempts ?? CONTENT_HASH_INDEX_RETRY_MAX_ATTEMPTS;
-    const baseMs = this.lockOptions.retryBaseMs ?? CONTENT_HASH_INDEX_RETRY_BASE_MS;
-    for (let attempt = 0; this.dirty && attempt < maxAttempts; attempt += 1) {
-      if (this.reconcileRetryTimer) {
-        clearTimeout(this.reconcileRetryTimer);
-        this.reconcileRetryTimer = null;
-      }
-      await this.saveMergingWithDisk();
-      if (!this.dirty) break;
-      if (attempt < maxAttempts - 1) {
-        const wait = Math.min(baseMs * 2 ** attempt, CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS);
-        await new Promise((resolve) => setTimeout(resolve, wait));
-      }
-    }
-    if (this.reconcileRetryTimer) {
-      clearTimeout(this.reconcileRetryTimer);
-      this.reconcileRetryTimer = null;
-    }
-    this.reconcileRetryAttempts = 0;
-    this.settleReconcileRetry();
-  }
-  /**
-   * Schedule ONE bounded, exponentially-backed-off background retry of the
-   * deferred reconcile save (PR #2016). Reentrant-safe: an already-armed timer
-   * short-circuits, so successive timed-out saves never stack duplicate retries.
-   * When attempts are exhausted the chain settles without publishing — the
-   * durable fact `.md` is on disk and a process restart rebuilds the index from
-   * the corpus, so this degrades to that safety net, never a fatal failure.
-   */
-  scheduleReconcileRetry() {
-    if (this.reconcileRetryTimer) return;
-    const maxAttempts = this.lockOptions.retryMaxAttempts ?? CONTENT_HASH_INDEX_RETRY_MAX_ATTEMPTS;
-    if (this.reconcileRetryAttempts >= maxAttempts) {
-      log.warn(
-        `content-hash index: exhausted ${maxAttempts} deferred reconcile-save retries for ${this.filePath}; ${this.added.size} addition(s) remain dirty in-memory (a process restart rebuilds the index from the durable corpus)`
-      );
-      this.reconcileRetryAttempts = 0;
-      this.settleReconcileRetry();
-      return;
-    }
-    if (!this.reconcileRetryBarrier) {
-      this.reconcileRetryBarrier = new Promise((resolve) => {
-        this.reconcileRetryResolve = resolve;
-      });
-    }
-    const attempt = this.reconcileRetryAttempts + 1;
-    const baseMs = this.lockOptions.retryBaseMs ?? CONTENT_HASH_INDEX_RETRY_BASE_MS;
-    const delay = Math.min(baseMs * 2 ** (attempt - 1), CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS);
-    this.reconcileRetryTimer = setTimeout(() => {
-      this.reconcileRetryTimer = null;
-      this.reconcileRetryAttempts = attempt;
-      void this.saveMergingWithDisk().catch((err) => {
-        log.warn(`content-hash index: deferred reconcile-save retry failed for ${this.filePath}: ${err}`);
-      }).finally(() => {
-        if (this.dirty && !this.reconcileRetryTimer) this.settleReconcileRetry();
-      });
-    }, delay);
-    this.reconcileRetryTimer.unref?.();
-  }
-  /** Cancel any armed reconcile-save retry and settle the barrier (a publish landed). */
-  cancelReconcileRetry() {
-    if (this.reconcileRetryTimer) {
-      clearTimeout(this.reconcileRetryTimer);
-      this.reconcileRetryTimer = null;
-    }
-    this.reconcileRetryAttempts = 0;
-    this.settleReconcileRetry();
-  }
-  /** Resolve and clear the retry barrier if one is outstanding. */
-  settleReconcileRetry() {
-    const resolve = this.reconcileRetryResolve;
-    this.reconcileRetryBarrier = null;
-    this.reconcileRetryResolve = null;
-    resolve?.();
-  }
-  /** Remove a hash from the index (used when archiving/deleting). */
-  remove(content) {
-    const hash = _ContentHashIndex.computeHash(content);
-    this.added.delete(hash);
-    this.removed.add(hash);
-    this.hashes.delete(hash);
-    this.dirty = true;
-  }
-  /**
-   * Remove a pre-computed SHA-256 hash directly from the index without
-   * re-hashing.  Use this when the caller already holds the stored hash
-   * (e.g. `memory.frontmatter.contentHash`) to avoid the double-hash bug
-   * where `remove(hash)` would compute `hash(hash)` and never match the
-   * entry.
-   */
-  removeByHash(hash) {
-    this.added.delete(hash);
-    this.removed.add(hash);
-    this.hashes.delete(hash);
-    this.dirty = true;
-  }
-  /**
-   * Add a pre-computed SHA-256 hash directly to the index without re-hashing.
-   * Use this when the caller already holds the stored hash
-   * (e.g. `memory.frontmatter.contentHash`) so that the index records the raw
-   * content hash rather than re-hashing the citation-annotated body.
-   *
-   * @internal Only called from `StorageManager.ensureFactHashIndexAuthoritative`.
-   * Not part of the public API — prefer `add(content)` for external callers.
-   */
-  addByHash(hash) {
-    this.removed.delete(hash);
-    this.hashes.add(hash);
-    this.added.add(hash);
-    this.dirty = true;
-  }
-  /** Normalize content (delegates to content-hash.ts for a single source of truth). */
-  static normalizeContent(content) {
-    return normalizeContent(content);
-  }
-  /** Compute SHA-256 hash (delegates to content-hash.ts for a single source of truth). */
-  static computeHash(content) {
-    return computeContentHash(content);
-  }
-};
-
 // src/storage/tombstone-blocked-capture-mutation.ts
 import { AsyncLocalStorage } from "async_hooks";
 import { createHash } from "crypto";
-import { mkdir as mkdir2 } from "fs/promises";
-import path2 from "path";
+import { mkdir } from "fs/promises";
+import path from "path";
 var TOMBSTONE_CAPTURE_WRITE_LOCK_STALE_MS = 6e4;
 var CAPTURE_WRITE_LOCK_MAX_ATTEMPTS = 3;
 var CAPTURE_WRITE_LOCK_RETRY_BASE_MS = 25;
@@ -538,10 +60,10 @@ var TombstoneBlockedCaptureWriteLock = class {
   context = new AsyncLocalStorage();
   captureWriteLockPathForHash(identityHash) {
     const filename = identityHash.length === 0 ? "explicit-capture-write.lock" : `explicit-capture-write-${identityHash}.lock`;
-    return path2.join(this.options.stateDir, "tombstone-blocked-capture", filename);
+    return path.join(this.options.stateDir, "tombstone-blocked-capture", filename);
   }
   async withSingleCaptureWriteLock(lockPath, task) {
-    await mkdir2(path2.dirname(lockPath), { recursive: true });
+    await mkdir(path.dirname(lockPath), { recursive: true });
     const retry = /* @__PURE__ */ Symbol("retry");
     const permanentFailure = /* @__PURE__ */ Symbol("permanent-failure");
     const runWithHeldFileLock = this.options.withHeldFileLock ?? withHeldFileLock;
@@ -693,14 +215,14 @@ async function runTombstoneBlockedChunkMutation(mutation) {
 // src/storage/tombstone-blocked-capture-sync.ts
 import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
 import { unlink as unlink2 } from "fs/promises";
-import path4 from "path";
+import path3 from "path";
 import { isDeepStrictEqual } from "util";
 
 // src/storage/tombstone-blocked-capture-index.ts
 import { execFile } from "child_process";
 import { randomUUID } from "crypto";
-import { mkdir as mkdir3, readFile, readdir, rename, stat as stat2, unlink, writeFile } from "fs/promises";
-import path3 from "path";
+import { mkdir as mkdir2, readFile, readdir, rename, stat, unlink, writeFile } from "fs/promises";
+import path2 from "path";
 import { promisify } from "util";
 var REBUILD_MAX_ATTEMPTS = 3;
 var execFileAsync = promisify(execFile);
@@ -722,7 +244,7 @@ var TombstoneBlockedCaptureIndex = class {
   }
   createIndex() {
     return new ContentHashIndex(
-      path3.join(this.options.stateDir, "tombstone-blocked-capture"),
+      path2.join(this.options.stateDir, "tombstone-blocked-capture"),
       this.options.secureStoreKeyProvider,
       this.options.secureStoreWriteKeyProvider,
       this.options.memoryDir,
@@ -730,17 +252,17 @@ var TombstoneBlockedCaptureIndex = class {
     );
   }
   indexPath() {
-    return path3.join(this.options.stateDir, "tombstone-blocked-capture", "fact-hashes.txt");
+    return path2.join(this.options.stateDir, "tombstone-blocked-capture", "fact-hashes.txt");
   }
   rebuildMarkerPath() {
-    return path3.join(this.options.stateDir, "tombstone-blocked-capture", "rebuild-required");
+    return path2.join(this.options.stateDir, "tombstone-blocked-capture", "rebuild-required");
   }
   async readRebuildMarkers() {
     try {
       const entries = (await readdir(this.rebuildMarkerPath())).filter((entry) => !entry.startsWith("."));
       return (await Promise.all(
         entries.map(async (entry) => {
-          const markerPath = path3.join(this.rebuildMarkerPath(), entry);
+          const markerPath = path2.join(this.rebuildMarkerPath(), entry);
           try {
             const raw = (await readFile(markerPath, "utf8")).trim();
             if (raw === "committed") return { path: markerPath, committed: true };
@@ -760,10 +282,10 @@ var TombstoneBlockedCaptureIndex = class {
             }
             const state = value.state;
             if (state !== "pending" && state !== "committed") malformed = true;
-            const markerStat = await stat2(markerPath).catch(() => null);
+            const markerStat = await stat(markerPath).catch(() => null);
             const createdAt = typeof value.createdAt === "number" && Number.isFinite(value.createdAt) ? value.createdAt : markerStat?.mtimeMs;
             if (typeof value.pid !== "number" || !Number.isInteger(value.pid)) malformed = true;
-            const ownerId = typeof value.ownerId === "string" && value.ownerId.length > 0 ? value.ownerId : path3.basename(markerPath);
+            const ownerId = typeof value.ownerId === "string" && value.ownerId.length > 0 ? value.ownerId : path2.basename(markerPath);
             if (typeof value.ownerId !== "string" || value.ownerId.length === 0) malformed = true;
             const processStartedAtMs = typeof value.processStartedAtMs === "number" && Number.isFinite(value.processStartedAtMs) && value.processStartedAtMs > 0 ? value.processStartedAtMs : void 0;
             return {
@@ -855,9 +377,9 @@ var TombstoneBlockedCaptureIndex = class {
   }
   async markRebuildRequired(committed = false) {
     const markerDir = this.rebuildMarkerPath();
-    await mkdir3(markerDir, { recursive: true });
+    await mkdir2(markerDir, { recursive: true });
     const ownerId = randomUUID();
-    const markerPath = path3.join(markerDir, ownerId);
+    const markerPath = path2.join(markerDir, ownerId);
     await this.writeMarkerAtomically(
       markerPath,
       `${JSON.stringify({
@@ -877,7 +399,7 @@ var TombstoneBlockedCaptureIndex = class {
       `${JSON.stringify({
         state: "committed",
         pid: process.pid,
-        ownerId: path3.basename(markerPath),
+        ownerId: path2.basename(markerPath),
         createdAt: Date.now(),
         processStartedAtMs: MARKER_PROCESS_STARTED_AT_MS
       })}
@@ -919,7 +441,7 @@ var TombstoneBlockedCaptureIndex = class {
   }
   async hasPersistedIndexOrMarkers() {
     try {
-      await stat2(this.indexPath());
+      await stat(this.indexPath());
       return true;
     } catch (err) {
       if (!isErrnoCode(err, "ENOENT")) throw err;
@@ -936,7 +458,7 @@ var TombstoneBlockedCaptureIndex = class {
         const clearableRebuildMarkers = await this.getClearableRebuildMarkerPaths(rebuildMarkers);
         let persisted = true;
         try {
-          await stat2(this.indexPath());
+          await stat(this.indexPath());
           if (rebuildMarkers.length > 0) persisted = false;
         } catch (err) {
           if (isErrnoCode(err, "ENOENT")) persisted = false;
@@ -1121,8 +643,8 @@ var TombstoneBlockedCaptureIndex = class {
     await this.failOpen("writeMemoryFrontmatter", () => this.sync(before, { ...before, frontmatter }, rebuildMarker));
   }
   shouldRebuildAfterInvalidationForPath(filePath) {
-    const relative = path3.relative(path3.resolve(this.options.memoryDir), path3.resolve(filePath));
-    const category = relative.split(path3.sep)[0];
+    const relative = path2.relative(path2.resolve(this.options.memoryDir), path2.resolve(filePath));
+    const category = relative.split(path2.sep)[0];
     return category === "cold" || RECALL_FALLBACK_DIRS.includes(category);
   }
 };
@@ -1383,11 +905,11 @@ var TombstoneBlockedCaptureIndexHost = class {
     this.invalidateAllMemoriesCache();
     this.invalidateKnowledgeIndexCache();
     this.markFactHashIndexNotAuthoritative();
-    if (filePath.includes(`${path4.sep}cold${path4.sep}`)) {
+    if (filePath.includes(`${path3.sep}cold${path3.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
     await this.rebuildTombstoneBlockedCaptureAfterInvalidationForPath(filePath, ownedMarker);
-    if (filePath.includes(`${path4.sep}artifacts${path4.sep}`)) {
+    if (filePath.includes(`${path3.sep}artifacts${path3.sep}`)) {
       this.bumpArtifactWriteVersion();
     }
     this.bumpMemoryStatusVersion();
@@ -1483,7 +1005,7 @@ var TombstoneBlockedCaptureIndexHost = class {
         const memoryDir = this.tombstoneBlockedCaptureIndexOptions().memoryDir;
         markProjectedMemoryPathInvalid(memoryDir, current.frontmatter.id);
         this.invalidateAllMemoriesCache();
-        if (current.path.includes(`${path4.sep}cold${path4.sep}`)) {
+        if (current.path.includes(`${path3.sep}cold${path3.sep}`)) {
           this.invalidateColdMemoriesCache();
         }
         await this.rebuildTombstoneBlockedCaptureAfterInvalidation(rebuildMarker);
@@ -1601,7 +1123,7 @@ var TombstoneBlockedCaptureIndexHost = class {
       return { after, chunks: replay };
     }
     const options = this.tombstoneBlockedCaptureIndexOptions();
-    const stagePath = path4.join(
+    const stagePath = path3.join(
       options.stateDir,
       "tombstone-blocked-capture",
       "offline-sync-staging",
@@ -1738,7 +1260,7 @@ var TombstoneBlockedCaptureIndexHost = class {
    */
   async requestSyncReconcileIfMemoryPath(target) {
     const stateDir = this.tombstoneBlockedCaptureIndexOptions().stateDir;
-    if (!pathMayCarryEntityRefs(path4.dirname(stateDir), target)) return;
+    if (!pathMayCarryEntityRefs(path3.dirname(stateDir), target)) return;
     await requestEntityCanonicalIdReconcile(stateDir);
   }
   async deleteOfflineSyncFile(filePath) {
@@ -1774,13 +1296,10 @@ var TombstoneBlockedCaptureIndexHost = class {
 };
 
 export {
-  CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS,
-  FactHashIndexNotAuthoritativeError,
-  ContentHashIndex,
   isTombstoneBlockedCaptureWriteLockBusy,
   normalizeExplicitCaptureContent,
   buildExplicitCaptureDedupKey,
   parseTombstoneBlockedOfflineSyncMemory,
   TombstoneBlockedCaptureIndexHost
 };
-//# sourceMappingURL=chunk-BEQOZOYZ.js.map
+//# sourceMappingURL=chunk-RVLJEII5.js.map