@remnic/core 10.0.13 → 10.0.15

package/dist/{chunk-RT6D3WN7.js → chunk-IJMDBYCO.js}

@@ -4,7 +4,7 @@ import {
 import {
   computeCorpusWatermarks,
   resolveCorpusNamespaceRoots
-} from "./chunk-P34FDDB5.js";
+} from "./chunk-QSEUUQUF.js";
 
 // src/operator-doctor-corpus.ts
 var DIGEST_PREFIX_LENGTH = 12;
@@ -78,4 +78,4 @@ export {
   corpusWatermarksFromCheck,
   summarizeCorpusAndReplica
 };
-//# sourceMappingURL=chunk-RT6D3WN7.js.map
+//# sourceMappingURL=chunk-IJMDBYCO.js.map

package/dist/{chunk-CS2JEHTB.js → chunk-IUCPLBDS.js}

@@ -1,14 +1,14 @@
-import {
-  normalizeDreamsStatusWindowHours
-} from "./chunk-EQWEIIKQ.js";
 import {
   runGraphEdgeDecayMaintenanceAcrossNamespaces
-} from "./chunk-Y6DZ33PA.js";
+} from "./chunk-5GX5457J.js";
+import {
+  normalizeDreamsStatusWindowHours
+} from "./chunk-PQM3B54K.js";
 import {
   executeResolution,
   isValidResolutionVerb,
   runPreferenceDriftScan
-} from "./chunk-NSFOERZQ.js";
+} from "./chunk-LWFWZTWX.js";
 import {
   getRecallTimingStatus,
   isRecallTimingsOperator
@@ -21,13 +21,13 @@ import {
   defineOperation,
   parseNamespacePreflightWriteOp,
   resolveAuthorizedNamespaceWritablePreflight
-} from "./chunk-3J5JKBYD.js";
+} from "./chunk-XLBFX63V.js";
 import {
   parseSharedWriteOutputControls
 } from "./chunk-IFBSZGW3.js";
 import {
   validateBriefingFormat
-} from "./chunk-UOKPJFO3.js";
+} from "./chunk-VNZMZPAC.js";
 import {
   parseDeepRecallMaxSteps
 } from "./chunk-A7AISUJI.js";
@@ -44,7 +44,7 @@ import {
   recallRequestSchema,
   retainedCategoryAlias,
   suggestionSubmitRequestSchema
-} from "./chunk-CBP4HWCL.js";
+} from "./chunk-RYYVMZBR.js";
 import {
   enforceNamespaceAllowList,
   tokenCapabilityStore
@@ -603,4 +603,4 @@ defineOperation({ name: "graph_events", description: "SSE graph events.", schema
 defineOperation({ name: "chat_message", description: "Chat message.", schema: strictSchema({ message: S.str, chatSessionId: S.str }), handler: async (_i, _ctx) => ({ result: { ok: true } }) });
 defineOperation({ name: "chat_events", description: "SSE chat events.", schema: strictSchema({}), handler: async (_i, _ctx) => ({ result: { stream: "sse" } }) });
 defineOperation({ name: "adapters_status", description: "Adapter registry metadata (issue #1850 round 5). Marker op: the HTTP transport builds the response from its own adapterRegistry, but the op still must be registered so it appears in listRegisteredOperations and enforceTokenOp can gate it for scoped tokens.", schema: strictSchema({}), handler: async (_i, _ctx) => ({ result: { ok: true } }) });
-//# sourceMappingURL=chunk-CS2JEHTB.js.map
+//# sourceMappingURL=chunk-IUCPLBDS.js.map

package/dist/{chunk-XRBHXUTQ.js → chunk-IWD33CF4.js}

@@ -3,7 +3,7 @@ import {
   headerConnector,
   renderExtractionConversation,
   resolveSourceConnector
-} from "./chunk-ZUMXY4KA.js";
+} from "./chunk-22W2XWGH.js";
 import {
   normalizeReasoningTrace
 } from "./chunk-54V4BZWP.js";
@@ -28,10 +28,10 @@ import {
   buildSpanMaterializeTurns,
   stripUntrustedFactSpans,
   truncateLocalExtractionConversation
-} from "./chunk-FZVROZKC.js";
+} from "./chunk-XVZA6VXC.js";
 import {
   attachExtractionProvenance
-} from "./chunk-YRH3C2OJ.js";
+} from "./chunk-CIIHIAJ2.js";
 import {
   containsExtractionPlaceholder,
   extractionAttributes,
@@ -76,7 +76,7 @@ import {
 } from "./chunk-EI6V5UXY.js";
 import {
   ProfilingCollector
-} from "./chunk-BLVHDY2U.js";
+} from "./chunk-DOWACHYO.js";
 import {
   ModelRegistry
 } from "./chunk-5MA7ZLPD.js";
@@ -102,7 +102,7 @@ import {
 } from "./chunk-YBA52OKG.js";
 import {
   isMemoryCategory
-} from "./chunk-OFCHT2TN.js";
+} from "./chunk-5LRV557D.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
@@ -2437,4 +2437,4 @@ export {
   shouldEnableLocalExtractionThinking,
   ExtractionEngine
 };
-//# sourceMappingURL=chunk-XRBHXUTQ.js.map
+//# sourceMappingURL=chunk-IWD33CF4.js.map

package/dist/{chunk-4IHBN6WU.js → chunk-JKMIGCK6.js}

@@ -2,7 +2,7 @@ import {
   listJsonFiles,
   listNamedFiles,
   readJsonFile
-} from "./chunk-B6O2YLUR.js";
+} from "./chunk-2Z5DIDQD.js";
 
 // src/evals.ts
 import path from "path";
@@ -897,4 +897,4 @@ export {
   runEvalStoredBaselineCiGate,
   runEvalBenchmarkCiGate
 };
-//# sourceMappingURL=chunk-4IHBN6WU.js.map
+//# sourceMappingURL=chunk-JKMIGCK6.js.map

package/dist/{chunk-YYO447A7.js → chunk-JNIVZNIB.js}

@@ -2,7 +2,16 @@ import {
   pathMayCarryEntityRefs,
   requestEntityCanonicalIdReconcile,
   withRawEntityPageMutation
-} from "./chunk-4NDWE44P.js";
+} from "./chunk-NZFFGO5O.js";
+import {
+  TombstoneBlockedCaptureWriteLock,
+  buildCapturePathLockIdentity,
+  buildExplicitCaptureDedupKey,
+  captureIdentityHash,
+  isQueuedReviewMemory,
+  runTombstoneBlockedMutation,
+  tombstoneBlocked
+} from "./chunk-6EDW54SQ.js";
 import {
   bumpArchiveMutationForPath
 } from "./chunk-W5BIQOAJ.js";
@@ -12,10 +21,10 @@ import {
 import {
   CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS,
   ContentHashIndex
-} from "./chunk-KI6UOSNR.js";
+} from "./chunk-DEY7B77Y.js";
 import {
   withHeldFileLock
-} from "./chunk-EHRE7ZG3.js";
+} from "./chunk-5B5WYAHQ.js";
 import {
   resolveSafeStoragePath
 } from "./chunk-LDPPTPO5.js";
@@ -1050,236 +1059,17 @@ var CasRevisionHost = class extends CasRevisionStore {
   }
 };
 
-// src/storage/tombstone-blocked-capture-mutation.ts
-import { AsyncLocalStorage } from "async_hooks";
-import { createHash as createHash3 } from "crypto";
-import { mkdir as mkdir3 } from "fs/promises";
-import path3 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;
-var CAPTURE_WRITE_LOCK_BUSY_MESSAGE = "tombstone-blocked capture write lock remained busy";
-function isTombstoneBlockedCaptureWriteLockBusy(error) {
-  return error instanceof Error && error.message === CAPTURE_WRITE_LOCK_BUSY_MESSAGE;
-}
-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 createHash3("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 path3.join(this.options.stateDir, "tombstone-blocked-capture", filename);
-  }
-  async withSingleCaptureWriteLock(lockPath, task) {
-    await mkdir3(path3.dirname(lockPath), { recursive: true });
-    const retry = /* @__PURE__ */ Symbol("retry");
-    const permanentFailure = /* @__PURE__ */ Symbol("permanent-failure");
-    const runWithHeldFileLock = this.options.withHeldFileLock ?? withHeldFileLock;
-    for (let attempt = 0; attempt < CAPTURE_WRITE_LOCK_MAX_ATTEMPTS; attempt += 1) {
-      const result = await runWithHeldFileLock(
-        lockPath,
-        {
-          staleMs: TOMBSTONE_CAPTURE_WRITE_LOCK_STALE_MS,
-          maxWaitMs: 1e3,
-          pollMs: 25
-        },
-        async (acquired, controller) => {
-          if (acquired) return await task();
-          return controller.failure === "error" ? permanentFailure : retry;
-        }
-      );
-      if (result === permanentFailure) {
-        throw new Error("tombstone-blocked capture write lock acquisition failed");
-      }
-      if (result !== retry) return result;
-      if (attempt === CAPTURE_WRITE_LOCK_MAX_ATTEMPTS - 1) break;
-      const delayState = Promise.withResolvers();
-      setTimeout(delayState.resolve, CAPTURE_WRITE_LOCK_RETRY_BASE_MS * 2 ** attempt);
-      await delayState.promise;
-    }
-    throw new Error(CAPTURE_WRITE_LOCK_BUSY_MESSAGE);
-  }
-  async withPhysicalCaptureWriteLocks(task, identityHashes) {
-    const lockPaths = [...new Set(identityHashes.map((hash) => this.captureWriteLockPathForHash(hash)))];
-    const acquire = async (index) => {
-      if (index === lockPaths.length) return await task();
-      return await this.withSingleCaptureWriteLock(lockPaths[index], () => acquire(index + 1));
-    };
-    return await acquire(0);
-  }
-  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) {
-    const current = this.context.getStore();
-    const hashToken = (key) => `\0${key.length === 0 ? "" : createHash3("sha256").update(key).digest("hex")}`;
-    const identityHash = (key) => key.length === 0 ? "" : createHash3("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 = () => 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);
-}
-
 // src/storage/tombstone-blocked-capture-sync.ts
-import { createHash as createHash4, randomUUID as randomUUID4 } from "crypto";
+import { createHash as createHash3, randomUUID as randomUUID4 } from "crypto";
 import { unlink as unlink4 } from "fs/promises";
-import path5 from "path";
+import path4 from "path";
 import { isDeepStrictEqual } from "util";
 
 // src/storage/tombstone-blocked-capture-index.ts
 import { execFile } from "child_process";
 import { randomUUID as randomUUID3 } from "crypto";
-import { mkdir as mkdir4, readFile as readFile3, readdir, rename as rename3, stat, unlink as unlink3, writeFile } from "fs/promises";
-import path4 from "path";
+import { mkdir as mkdir3, readFile as readFile3, readdir, rename as rename3, stat, unlink as unlink3, writeFile } from "fs/promises";
+import path3 from "path";
 import { promisify } from "util";
 var REBUILD_MAX_ATTEMPTS = 3;
 var execFileAsync = promisify(execFile);
@@ -1297,11 +1087,15 @@ var TombstoneBlockedCaptureIndex = class {
   captureWriteLock;
   constructor(options) {
     this.options = options;
-    this.captureWriteLock = new TombstoneBlockedCaptureWriteLock(options);
+    this.captureWriteLock = new TombstoneBlockedCaptureWriteLock({
+      stateDir: options.stateDir,
+      withHeldFileLock: options.withHeldFileLock,
+      lockOptions: options.captureLockLimitSource
+    });
   }
   createIndex() {
     return new ContentHashIndex(
-      path4.join(this.options.stateDir, "tombstone-blocked-capture"),
+      path3.join(this.options.stateDir, "tombstone-blocked-capture"),
       this.options.secureStoreKeyProvider,
       this.options.secureStoreWriteKeyProvider,
       this.options.memoryDir,
@@ -1309,17 +1103,17 @@ var TombstoneBlockedCaptureIndex = class {
     );
   }
   indexPath() {
-    return path4.join(this.options.stateDir, "tombstone-blocked-capture", "fact-hashes.txt");
+    return path3.join(this.options.stateDir, "tombstone-blocked-capture", "fact-hashes.txt");
   }
   rebuildMarkerPath() {
-    return path4.join(this.options.stateDir, "tombstone-blocked-capture", "rebuild-required");
+    return path3.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 = path4.join(this.rebuildMarkerPath(), entry);
+          const markerPath = path3.join(this.rebuildMarkerPath(), entry);
           try {
             const raw = (await readFile3(markerPath, "utf8")).trim();
             if (raw === "committed") return { path: markerPath, committed: true };
@@ -1342,7 +1136,7 @@ var TombstoneBlockedCaptureIndex = class {
             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 : path4.basename(markerPath);
+            const ownerId = typeof value.ownerId === "string" && value.ownerId.length > 0 ? value.ownerId : path3.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 {
@@ -1434,9 +1228,9 @@ var TombstoneBlockedCaptureIndex = class {
   }
   async markRebuildRequired(committed = false) {
     const markerDir = this.rebuildMarkerPath();
-    await mkdir4(markerDir, { recursive: true });
+    await mkdir3(markerDir, { recursive: true });
     const ownerId = randomUUID3();
-    const markerPath = path4.join(markerDir, ownerId);
+    const markerPath = path3.join(markerDir, ownerId);
     await this.writeMarkerAtomically(
       markerPath,
       `${JSON.stringify({
@@ -1456,7 +1250,7 @@ var TombstoneBlockedCaptureIndex = class {
       `${JSON.stringify({
         state: "committed",
         pid: process.pid,
-        ownerId: path4.basename(markerPath),
+        ownerId: path3.basename(markerPath),
         createdAt: Date.now(),
         processStartedAtMs: MARKER_PROCESS_STARTED_AT_MS
       })}
@@ -1708,8 +1502,8 @@ var TombstoneBlockedCaptureIndex = class {
     await this.failOpen("writeMemoryFrontmatter", () => this.sync(before, { ...before, frontmatter }, rebuildMarker));
   }
   shouldRebuildAfterInvalidationForPath(filePath) {
-    const relative = path4.relative(path4.resolve(this.options.memoryDir), path4.resolve(filePath));
-    const category = relative.split(path4.sep)[0];
+    const relative = path3.relative(path3.resolve(this.options.memoryDir), path3.resolve(filePath));
+    const category = relative.split(path3.sep)[0];
     return category === "cold" || RECALL_FALLBACK_DIRS.includes(category);
   }
 };
@@ -2070,7 +1864,7 @@ var TombstoneBlockedCaptureIndexHost = class {
     this.invalidateAllMemoriesCache();
     this.invalidateKnowledgeIndexCache();
     this.markFactHashIndexNotAuthoritative();
-    if (filePath.includes(`${path5.sep}cold${path5.sep}`)) {
+    if (filePath.includes(`${path4.sep}cold${path4.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
     if (blockedKeySetMayHaveChanged) {
@@ -2083,7 +1877,7 @@ var TombstoneBlockedCaptureIndexHost = class {
         log.warn(`storage.offlineSyncFile committed write succeeded; marker cleanup failed: ${err}`);
       }
     }
-    if (filePath.includes(`${path5.sep}artifacts${path5.sep}`)) {
+    if (filePath.includes(`${path4.sep}artifacts${path4.sep}`)) {
       this.bumpArtifactWriteVersion();
     }
     const memoryDir = this.tombstoneBlockedCaptureIndexOptions().memoryDir;
@@ -2178,7 +1972,7 @@ var TombstoneBlockedCaptureIndexHost = class {
         bumpArchiveMutationForPath(memoryDir, true, current.path);
         markProjectedMemoryPathInvalid(memoryDir, current.frontmatter.id);
         this.invalidateAllMemoriesCache();
-        if (current.path.includes(`${path5.sep}cold${path5.sep}`)) {
+        if (current.path.includes(`${path4.sep}cold${path4.sep}`)) {
           this.invalidateColdMemoriesCache();
         }
         await this.rebuildTombstoneBlockedCaptureAfterInvalidation(rebuildMarker);
@@ -2261,7 +2055,7 @@ var TombstoneBlockedCaptureIndexHost = class {
   async writeTombstoneBlockedOfflineSyncFile(target, content) {
     const options = this.tombstoneBlockedCaptureIndexOptions();
     const after = options.parseMemory?.(target, content) ?? null;
-    await withRawEntityPageMutation(path5.dirname(options.stateDir), target, async () => {
+    await withRawEntityPageMutation(path4.dirname(options.stateDir), target, async () => {
       await this.runTombstoneBlockedOfflineSyncMutation(
         target,
         after,
@@ -2300,7 +2094,7 @@ var TombstoneBlockedCaptureIndexHost = class {
       return { after, chunks: replay };
     }
     const options = this.tombstoneBlockedCaptureIndexOptions();
-    const stagePath = path5.join(
+    const stagePath = path4.join(
       options.stateDir,
       "tombstone-blocked-capture",
       "offline-sync-staging",
@@ -2379,7 +2173,7 @@ var TombstoneBlockedCaptureIndexHost = class {
       encode("connector", connector),
       `content ${normalizedLength} `
     ].join(" ");
-    let identityHash = createHash4("sha256");
+    let identityHash = createHash3("sha256");
     let normalSigmaIdentityHash;
     identityHash.update(identityPrefix);
     const identityNormalizer = createExplicitContentNormalizer({
@@ -2425,7 +2219,7 @@ var TombstoneBlockedCaptureIndexHost = class {
     const coordinate = this.getTombstoneBlockedCaptureIndex().shouldRebuildAfterInvalidationForPath(target);
     const prepared = coordinate ? await this.prepareTombstoneBlockedOfflineSyncChunks(target, chunks) : { after: null, chunks };
     const streamedIdentity = prepared.streamedIdentity;
-    const baseDir = path5.dirname(this.tombstoneBlockedCaptureIndexOptions().stateDir);
+    const baseDir = path4.dirname(this.tombstoneBlockedCaptureIndexOptions().stateDir);
     try {
       await withRawEntityPageMutation(baseDir, target, async () => {
         await this.runTombstoneBlockedOfflineSyncMutation(
@@ -2457,7 +2251,7 @@ var TombstoneBlockedCaptureIndexHost = class {
    */
   async requestSyncReconcileIfMigrationPath(target) {
     const stateDir = this.tombstoneBlockedCaptureIndexOptions().stateDir;
-    if (!pathMayCarryEntityRefs(path5.dirname(stateDir), target)) return;
+    if (!pathMayCarryEntityRefs(path4.dirname(stateDir), target)) return;
     await requestEntityCanonicalIdReconcile(stateDir);
   }
   async deleteOfflineSyncFile(filePath, deletionMtimeMs) {
@@ -2467,7 +2261,7 @@ var TombstoneBlockedCaptureIndexHost = class {
   }
   async deleteTombstoneBlockedOfflineSyncFile(target, deletionMtimeMs) {
     const stateDir = this.tombstoneBlockedCaptureIndexOptions().stateDir;
-    await withRawEntityPageMutation(path5.dirname(stateDir), target, async () => {
+    await withRawEntityPageMutation(path4.dirname(stateDir), target, async () => {
       await this.runTombstoneBlockedOfflineSyncMutation(target, null, async () => {
         return await this.deleteManagedStorageFile(target, deletionMtimeMs);
       });
@@ -2500,13 +2294,7 @@ export {
   DeletionRevisionStore,
   canonicalSemanticFileText,
   CasRevisionHost,
-  isTombstoneBlockedCaptureWriteLockBusy,
-  normalizeExplicitCaptureContent,
-  buildExplicitCaptureDedupKey,
-  buildCapturePathLockIdentity,
-  tombstoneBlocked,
-  isQueuedReviewMemory,
   parseTombstoneBlockedOfflineSyncMemory,
   TombstoneBlockedCaptureIndexHost
 };
-//# sourceMappingURL=chunk-YYO447A7.js.map
+//# sourceMappingURL=chunk-JNIVZNIB.js.map