@remnic/core 9.45.3 → 9.45.5

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

@@ -1,21 +1,22 @@
+import {
+  pathMayCarryEntityRefs,
+  requestEntityCanonicalIdReconcile,
+  withRawEntityPageMutation
+} from "./chunk-NZBZ7IS2.js";
 import {
   CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS,
   ContentHashIndex
-} from "./chunk-S5SLVSVY.js";
+} from "./chunk-BQIFZ2MP.js";
 import {
   markProjectedMemoryPathInvalid
 } from "./chunk-3CSX3ETE.js";
-import {
-  pathMayCarryEntityRefs,
-  requestEntityCanonicalIdReconcile
-} from "./chunk-4J7G5SY4.js";
 import {
   withHeldFileLock
 } from "./chunk-FFAZ2XFU.js";
 import {
   readMaybeEncryptedFileFromChunks,
   writeMaybeEncryptedFileFromChunks
-} from "./chunk-5TFP4CUL.js";
+} from "./chunk-XQ3HXAQH.js";
 import {
   isErrnoCode
 } from "./chunk-5UZXUTVO.js";
@@ -49,8 +50,13 @@ function buildExplicitCaptureDedupKey(content, category, sourceConnector) {
     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");
+  return createHash("sha256").update(
+    buildExplicitCaptureDedupKey(memory.content, memory.frontmatter.category, memory.frontmatter.sourceConnector)
+  ).digest("hex");
 }
 var TombstoneBlockedCaptureWriteLock = class {
   constructor(options) {
@@ -92,7 +98,7 @@ var TombstoneBlockedCaptureWriteLock = class {
     throw new Error(CAPTURE_WRITE_LOCK_BUSY_MESSAGE);
   }
   async withPhysicalCaptureWriteLocks(task, identityHashes) {
-    const lockPaths = [...new Set(identityHashes.map((hash) => this.captureWriteLockPathForHash(hash)))].sort();
+    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));
@@ -116,13 +122,26 @@ var TombstoneBlockedCaptureWriteLock = class {
     const identityHash = (key) => key.length === 0 ? "" : createHash("sha256").update(key).digest("hex");
     const identityKeys = [...new Set(identities)];
     const hashes = [...new Set(identityHashes)];
-    const missingIdentityHashes = identityKeys.filter((key) => !current || !current.has(key) && !current.has(hashToken(key))).map(identityHash);
-    const missingHashes = hashes.filter((hash) => !current || !current.has(`\0${hash}`));
-    const physicalMissing = [.../* @__PURE__ */ new Set([...missingIdentityHashes, ...missingHashes])];
-    if (current && physicalMissing.length > 0) {
-      const heldLockPaths = [...current].filter((token) => token.startsWith("\0")).map((token) => this.captureWriteLockPathForHash(token.slice(1)));
-      const requestedLockPaths = physicalMissing.map((hash) => this.captureWriteLockPathForHash(hash));
-      if (heldLockPaths.some((held) => requestedLockPaths.some((requested) => requested < held))) {
+    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);
       }
     }
@@ -139,14 +158,13 @@ var TombstoneBlockedCaptureWriteLock = class {
 };
 async function runTombstoneBlockedMutation(host, mutation) {
   let lockIdentity = mutation.identity;
-  let mustLock = mutation.blocked || mutation.coordinate === true;
   for (; ; ) {
     let retryIdentity;
     const mutate = async () => {
       const current = await host.readCurrent();
       const currentBlocked = host.isBlocked(current);
       const currentQueuedReview = host.isQueuedReview(current);
-      if (current !== null && (currentBlocked || currentQueuedReview)) {
+      if (current !== null && (mutation.coordinate === true || currentBlocked || currentQueuedReview)) {
         const currentIdentity = host.memoryIdentity(current);
         const heldIdentities = Array.isArray(lockIdentity) ? lockIdentity : [lockIdentity];
         if (!heldIdentities.includes(currentIdentity)) {
@@ -179,15 +197,10 @@ async function runTombstoneBlockedMutation(host, mutation) {
       if (rebuildMarker) await mutation.beforeIndexUpdate?.();
       await mutation.updateIndex(rebuildMarker, currentBlocked && current !== null ? current : void 0);
     };
-    if (mustLock) {
-      await host.withCaptureWriteLock(mutate, lockIdentity);
-    } else {
-      await mutate();
-    }
+    await host.withCaptureWriteLock(mutate, lockIdentity);
     if (retryIdentity === void 0) return;
     const identities = Array.isArray(lockIdentity) ? [...lockIdentity, retryIdentity] : [lockIdentity, retryIdentity];
     lockIdentity = [...new Set(identities)];
-    mustLock = true;
   }
 }
 function tombstoneBlocked(frontmatter) {
@@ -199,18 +212,6 @@ function isQueuedReviewFrontmatter(frontmatter) {
 function isQueuedReviewMemory(memory) {
   return memory !== null && isQueuedReviewFrontmatter(memory.frontmatter);
 }
-async function runTombstoneBlockedChunkMutation(mutation) {
-  const persist = async () => {
-    if (mutation.blocked) {
-      const duplicate = await mutation.findDuplicate();
-      if (duplicate) return duplicate.frontmatter.id;
-    }
-    await mutation.persistMemory();
-    await mutation.afterWrite();
-    return mutation.id;
-  };
-  return mutation.blocked ? await mutation.withCaptureWriteLock(persist, mutation.identity) : await persist();
-}
 
 // src/storage/tombstone-blocked-capture-sync.ts
 import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
@@ -653,33 +654,68 @@ var TombstoneBlockedCaptureIndex = class {
 var OFFLINE_SYNC_BUFFER_LIMIT_BYTES = 1048576;
 var OFFLINE_SYNC_STAGE_READ_BYTES = 64 * 1024;
 var OFFLINE_SYNC_FRONTMATTER_DELIMITER = Buffer.from("\n---\n", "utf8");
-function createExplicitContentNormalizer(onChunk) {
+var CASED_CHARACTER = /\p{Cased}/u;
+var CASE_IGNORABLE_CHARACTER = /\p{Case_Ignorable}/u;
+function createExplicitContentNormalizer(sink) {
   let started = false;
   let pendingSpace = false;
   let output = "";
+  let precededByCased = false;
+  let pendingSigma = false;
   const flush = () => {
     if (output.length > 0) {
-      onChunk(output);
+      sink.write(output);
       output = "";
     }
   };
-  return {
-    push(text) {
-      for (const character of text.toLowerCase()) {
-        if (/\s/u.test(character)) {
-          if (started) pendingSpace = true;
+  const emit = (text) => {
+    for (const character of text) {
+      if (/\s/u.test(character)) {
+        if (started) pendingSpace = true;
+        continue;
+      }
+      if (pendingSpace) {
+        output += " ";
+        pendingSpace = false;
+      }
+      output += character;
+      started = true;
+      if (output.length >= OFFLINE_SYNC_STAGE_READ_BYTES) flush();
+    }
+  };
+  const resolveSigma = (followedByCased) => {
+    flush();
+    sink.resolveConditionalSigma(!followedByCased);
+    pendingSigma = false;
+  };
+  const push = (text) => {
+    for (const character of text) {
+      const caseIgnorable = CASE_IGNORABLE_CHARACTER.test(character);
+      const cased = CASED_CHARACTER.test(character);
+      if (pendingSigma) {
+        if (caseIgnorable) {
+          emit(character.toLowerCase());
           continue;
         }
-        if (pendingSpace) {
-          output += " ";
-          pendingSpace = false;
-        }
-        output += character;
-        started = true;
-        if (output.length >= OFFLINE_SYNC_STAGE_READ_BYTES) flush();
+        resolveSigma(cased);
+      }
+      if (character === "\u03A3" && precededByCased) {
+        flush();
+        sink.beginConditionalSigma();
+        pendingSigma = true;
+        precededByCased = true;
+        continue;
       }
-    },
-    finish: flush
+      emit(character.toLowerCase());
+      if (!caseIgnorable) precededByCased = cased;
+    }
+  };
+  return {
+    push,
+    finish() {
+      if (pendingSigma) resolveSigma(false);
+      flush();
+    }
   };
 }
 async function forEachStagedTextChunk(stagePath, offset, onText, key, memoryDir) {
@@ -789,21 +825,65 @@ var TombstoneBlockedCaptureIndexHost = class {
       tombstoneBlocked(frontmatter),
       pathname,
       fileContent,
-      buildExplicitCaptureDedupKey(content, frontmatter.category, frontmatter.sourceConnector),
+      [
+        buildCapturePathLockIdentity(pathname),
+        buildExplicitCaptureDedupKey(content, frontmatter.category, frontmatter.sourceConnector)
+      ],
       (rebuildMarker) => this.getTombstoneBlockedCaptureIndex().addWrittenMemory(pathname, frontmatter, content, rebuildMarker),
       beforeIndexUpdate
     );
   }
+  async withTombstoneBlockedMemoryPathLock(pathname, task, additionalPathnames = []) {
+    let lockIdentities = [pathname, ...additionalPathnames].map(buildCapturePathLockIdentity);
+    for (; ; ) {
+      let retryIdentity;
+      let result;
+      await this.withTombstoneBlockedCaptureWriteLock(async () => {
+        const current = await this.readMemoryByPath(pathname);
+        if (current !== null) {
+          const currentIdentity = this.offlineSyncMemoryIdentity(current);
+          if (!lockIdentities.includes(currentIdentity)) {
+            retryIdentity = currentIdentity;
+            return;
+          }
+        }
+        result = await task(current);
+      }, lockIdentities);
+      if (retryIdentity !== void 0) {
+        lockIdentities = [.../* @__PURE__ */ new Set([...lockIdentities, retryIdentity])];
+        continue;
+      }
+      return result;
+    }
+  }
   async writeTombstoneBlockedChunk(pathname, fileContent, frontmatter, content, findDuplicate, afterWrite) {
-    return await runTombstoneBlockedChunkMutation({
-      blocked: tombstoneBlocked(frontmatter),
-      id: frontmatter.id,
-      identity: buildExplicitCaptureDedupKey(content, frontmatter.category, frontmatter.sourceConnector),
-      findDuplicate,
-      persistMemory: () => this.writeTombstoneBlockedMemory(pathname, fileContent, frontmatter, content),
-      afterWrite,
-      withCaptureWriteLock: (task, identity) => this.withTombstoneBlockedCaptureWriteLock(task, identity)
-    });
+    const incomingIdentity = buildExplicitCaptureDedupKey(content, frontmatter.category, frontmatter.sourceConnector);
+    let lockIdentities = [buildCapturePathLockIdentity(pathname), incomingIdentity];
+    for (; ; ) {
+      let retryIdentity;
+      let result = frontmatter.id;
+      await this.withTombstoneBlockedCaptureWriteLock(async () => {
+        const current = await this.readMemoryByPath(pathname);
+        if (current !== null) {
+          const currentIdentity = this.offlineSyncMemoryIdentity(current);
+          if (!lockIdentities.includes(currentIdentity)) {
+            retryIdentity = currentIdentity;
+            return;
+          }
+        }
+        if (tombstoneBlocked(frontmatter)) {
+          const duplicate = await findDuplicate();
+          if (duplicate) {
+            result = duplicate.frontmatter.id;
+            return;
+          }
+        }
+        await this.writeTombstoneBlockedMemory(pathname, fileContent, frontmatter, content);
+        await afterWrite(current);
+      }, lockIdentities);
+      if (retryIdentity === void 0) return result;
+      lockIdentities = [.../* @__PURE__ */ new Set([...lockIdentities, retryIdentity])];
+    }
   }
   async writeTombstoneBlockedUpdate(before, fileContent, frontmatter, content, beforeIndexUpdate) {
     await this.writeTombstoneBlockedMutation(
@@ -811,22 +891,9 @@ var TombstoneBlockedCaptureIndexHost = class {
       before.path,
       fileContent,
       [
-        ...tombstoneBlocked(before.frontmatter) ? [
-          buildExplicitCaptureDedupKey(
-            before.content,
-            before.frontmatter.category,
-            before.frontmatter.sourceConnector
-          )
-        ] : [],
-        ...tombstoneBlocked(frontmatter) ? [buildExplicitCaptureDedupKey(content, frontmatter.category, frontmatter.sourceConnector)] : [],
-        ...isQueuedReviewMemory(before) ? [
-          buildExplicitCaptureDedupKey(
-            before.content,
-            before.frontmatter.category,
-            before.frontmatter.sourceConnector
-          )
-        ] : [],
-        ...isQueuedReviewFrontmatter(frontmatter) ? [buildExplicitCaptureDedupKey(content, frontmatter.category, frontmatter.sourceConnector)] : []
+        buildCapturePathLockIdentity(before.path),
+        this.offlineSyncMemoryIdentity(before),
+        buildExplicitCaptureDedupKey(content, frontmatter.category, frontmatter.sourceConnector)
       ],
       (rebuildMarker, current) => this.getTombstoneBlockedCaptureIndex().syncUpdatedMemory(
         current ?? before,
@@ -835,7 +902,7 @@ var TombstoneBlockedCaptureIndexHost = class {
         rebuildMarker
       ),
       beforeIndexUpdate,
-      isQueuedReviewMemory(before) || isQueuedReviewFrontmatter(frontmatter)
+      true
     );
   }
   async writeTombstoneBlockedFrontmatter(before, fileContent, frontmatter, beforeIndexUpdate) {
@@ -844,30 +911,13 @@ var TombstoneBlockedCaptureIndexHost = class {
       before.path,
       fileContent,
       [
-        ...tombstoneBlocked(before.frontmatter) ? [
-          buildExplicitCaptureDedupKey(
-            before.content,
-            before.frontmatter.category,
-            before.frontmatter.sourceConnector
-          )
-        ] : [],
-        ...tombstoneBlocked(frontmatter) ? [buildExplicitCaptureDedupKey(before.content, frontmatter.category, frontmatter.sourceConnector)] : [],
-        ...isQueuedReviewMemory(before) ? [
-          buildExplicitCaptureDedupKey(
-            before.content,
-            before.frontmatter.category,
-            before.frontmatter.sourceConnector
-          )
-        ] : [],
-        ...isQueuedReviewFrontmatter(frontmatter) ? [buildExplicitCaptureDedupKey(before.content, frontmatter.category, frontmatter.sourceConnector)] : []
+        buildCapturePathLockIdentity(before.path),
+        this.offlineSyncMemoryIdentity(before),
+        buildExplicitCaptureDedupKey(before.content, frontmatter.category, frontmatter.sourceConnector)
       ],
-      (rebuildMarker, current) => this.getTombstoneBlockedCaptureIndex().syncUpdatedFrontmatter(
-        current ?? before,
-        frontmatter,
-        rebuildMarker
-      ),
+      (rebuildMarker, current) => this.getTombstoneBlockedCaptureIndex().syncUpdatedFrontmatter(current ?? before, frontmatter, rebuildMarker),
       beforeIndexUpdate,
-      isQueuedReviewMemory(before) || isQueuedReviewFrontmatter(frontmatter)
+      true
     );
   }
   isTombstoneBlockedMemory(memory) {
@@ -915,37 +965,33 @@ var TombstoneBlockedCaptureIndexHost = class {
     this.bumpMemoryStatusVersion();
   }
   async runTombstoneBlockedArchive(memory, task) {
-    if (!this.isTombstoneBlockedMemory(memory) && !isQueuedReviewMemory(memory)) {
-      return await task(memory, () => {
-      });
-    }
     let archivedPath = null;
-    const archived = await this.runTombstoneBlockedInvalidation(
-      memory,
-      async (current, rebuildMarker, markDurable) => {
-        let archiveDurable = false;
-        const markArchiveDurable = () => {
-          archiveDurable = true;
-          markDurable();
-        };
-        archivedPath = await task(current, markArchiveDurable);
-        if (rebuildMarker !== void 0 && (archivedPath !== null || archiveDurable)) {
-          await this.rebuildTombstoneBlockedCaptureAfterInvalidation(rebuildMarker);
-        } else if (rebuildMarker !== void 0) {
-          const index = this.getTombstoneBlockedCaptureIndex();
-          try {
-            await index.discardWrite(rebuildMarker);
-          } catch {
-            index.markUntrusted();
-          }
+    const archived = await this.runTombstoneBlockedInvalidation(memory, async (current, rebuildMarker, markDurable) => {
+      let archiveDurable = false;
+      const markArchiveDurable = () => {
+        archiveDurable = true;
+        markDurable();
+      };
+      archivedPath = await task(current, markArchiveDurable);
+      if (rebuildMarker !== void 0 && (archivedPath !== null || archiveDurable)) {
+        await this.rebuildTombstoneBlockedCaptureAfterInvalidation(rebuildMarker);
+      } else if (rebuildMarker !== void 0) {
+        const index = this.getTombstoneBlockedCaptureIndex();
+        try {
+          await index.discardWrite(rebuildMarker);
+        } catch {
+          index.markUntrusted();
         }
-        return archivedPath !== null;
       }
-    );
+      return archivedPath !== null;
+    });
     return archived ? archivedPath : null;
   }
   async runTombstoneBlockedInvalidation(memory, task, propagateErrors = false, coordinate = false) {
-    let lockIdentity = coordinate || this.isTombstoneBlockedMemory(memory) || isQueuedReviewMemory(memory) ? this.offlineSyncMemoryIdentity(memory) : void 0;
+    let lockIdentities = [
+      buildCapturePathLockIdentity(memory.path),
+      ...coordinate || this.isTombstoneBlockedMemory(memory) || isQueuedReviewMemory(memory) ? [this.offlineSyncMemoryIdentity(memory)] : []
+    ];
     for (; ; ) {
       const attempt = async () => {
         const options = this.tombstoneBlockedCaptureIndexOptions();
@@ -955,7 +1001,7 @@ var TombstoneBlockedCaptureIndexHost = class {
         const queuedReview = isQueuedReviewMemory(current);
         if (blocked || queuedReview) {
           const currentIdentity = this.offlineSyncMemoryIdentity(current);
-          if (lockIdentity !== currentIdentity) return { retryIdentity: currentIdentity };
+          if (!lockIdentities.includes(currentIdentity)) return { retryIdentity: currentIdentity };
         }
         const blockedIndex = blocked ? this.getTombstoneBlockedCaptureIndex() : null;
         let rebuildMarker;
@@ -985,9 +1031,9 @@ var TombstoneBlockedCaptureIndexHost = class {
           return { result: false };
         }
       };
-      const result = lockIdentity === void 0 ? await attempt() : await this.withTombstoneBlockedCaptureWriteLock(attempt, lockIdentity);
+      const result = await this.withTombstoneBlockedCaptureWriteLock(attempt, lockIdentities);
       if (result.retryIdentity !== void 0) {
-        lockIdentity = result.retryIdentity;
+        lockIdentities = [.../* @__PURE__ */ new Set([...lockIdentities, result.retryIdentity])];
         continue;
       }
       return result.result;
@@ -999,7 +1045,7 @@ var TombstoneBlockedCaptureIndexHost = class {
       memory,
       async (current, rebuildMarker, markDurable) => {
         if (!shouldDelete(current)) return false;
-        await unlink2(current.path);
+        if (!await this.deleteManagedStorageFile(current.path)) return false;
         markDurable();
         deleted = current;
         const memoryDir = this.tombstoneBlockedCaptureIndexOptions().memoryDir;
@@ -1021,18 +1067,18 @@ var TombstoneBlockedCaptureIndexHost = class {
   async runTombstoneBlockedOfflineSyncMutation(target, after, write, coordinate = false, streamedIdentity) {
     for (; ; ) {
       const before = await this.readMemoryByPath(target);
-      const targetIdentity = this.isTombstoneBlockedMemory(before) ? this.offlineSyncMemoryIdentity(before) : void 0;
-      const blocked = coordinate || targetIdentity !== void 0 || this.isTombstoneBlockedMemory(after);
+      const targetIdentity = before === null ? void 0 : this.offlineSyncMemoryIdentity(before);
+      const afterIdentity = after === null || streamedIdentity ? void 0 : this.offlineSyncMemoryIdentity(after);
+      const mustCoordinate = coordinate || targetIdentity !== void 0 || afterIdentity !== void 0 || streamedIdentity !== void 0;
       const identities = [
+        ...mustCoordinate ? [buildCapturePathLockIdentity(target)] : [],
         ...targetIdentity === void 0 ? [] : [targetIdentity],
-        ...!streamedIdentity && this.isTombstoneBlockedMemory(after) ? [this.offlineSyncMemoryIdentity(after)] : [],
-        ...coordinate ? [target] : [],
-        ...coordinate && after === null && streamedIdentity === void 0 ? [""] : []
+        ...afterIdentity === void 0 ? [] : [afterIdentity]
       ];
       let retryIdentity;
       const mutate = async () => {
         const current = await this.readMemoryByPath(target);
-        if (this.isTombstoneBlockedMemory(current)) {
+        if (current !== null) {
           const currentIdentity = this.offlineSyncMemoryIdentity(current);
           if (currentIdentity !== targetIdentity) {
             retryIdentity = currentIdentity;
@@ -1042,7 +1088,8 @@ var TombstoneBlockedCaptureIndexHost = class {
         if (this.isTombstoneBlockedMemory(after) && await this.isDuplicateTombstoneBlockedOfflineSync(target, after, streamedIdentity)) {
           return;
         }
-        const marker = blocked ? await this.getTombstoneBlockedCaptureIndex().prepareWrite() : void 0;
+        const affectsBlockedIndex = coordinate || this.isTombstoneBlockedMemory(current) || this.isTombstoneBlockedMemory(after);
+        const marker = affectsBlockedIndex ? await this.getTombstoneBlockedCaptureIndex().prepareWrite() : void 0;
         let durable = false;
         try {
           await write();
@@ -1068,29 +1115,27 @@ var TombstoneBlockedCaptureIndexHost = class {
           throw err;
         }
       };
-      if (!blocked) {
+      if (!mustCoordinate) {
         await mutate();
+      } else if (streamedIdentity) {
+        await this.withTombstoneBlockedCaptureWriteLockAndHashes(mutate, identities, [streamedIdentity.identityHash]);
       } else {
-        if (streamedIdentity) {
-          await this.withTombstoneBlockedCaptureWriteLockAndHashes(
-            mutate,
-            identities,
-            [streamedIdentity.identityHash]
-          );
-        } else {
-          await this.withTombstoneBlockedCaptureWriteLock(mutate, identities);
-        }
+        await this.withTombstoneBlockedCaptureWriteLock(mutate, identities);
       }
       if (retryIdentity !== void 0) continue;
       return;
     }
   }
   async writeTombstoneBlockedOfflineSyncFile(target, content) {
-    await this.runTombstoneBlockedOfflineSyncMutation(
-      target,
-      this.tombstoneBlockedCaptureIndexOptions().parseMemory?.(target, content) ?? null,
-      () => this.writeStorageSecureFile(target, content)
-    );
+    const options = this.tombstoneBlockedCaptureIndexOptions();
+    const after = options.parseMemory?.(target, content) ?? null;
+    await withRawEntityPageMutation(path3.dirname(options.stateDir), target, async () => {
+      await this.runTombstoneBlockedOfflineSyncMutation(
+        target,
+        after,
+        () => this.writeManagedStorageFile(target, () => this.writeStorageSecureFile(target, content))
+      );
+    });
   }
   async prepareTombstoneBlockedOfflineSyncChunks(target, chunks) {
     const parseMemory = this.tombstoneBlockedCaptureIndexOptions().parseMemory;
@@ -1180,26 +1225,48 @@ var TombstoneBlockedCaptureIndexHost = class {
   }
   async computeStagedOfflineSyncIdentity(stagePath, bodyOffset, after) {
     let normalizedLength = 0;
-    const countNormalizer = createExplicitContentNormalizer((chunk) => {
-      normalizedLength += chunk.length;
+    const countNormalizer = createExplicitContentNormalizer({
+      write: (chunk) => {
+        normalizedLength += chunk.length;
+      },
+      beginConditionalSigma: () => {
+        normalizedLength += 1;
+      },
+      resolveConditionalSigma: () => {
+      }
     });
     const options = this.tombstoneBlockedCaptureIndexOptions();
     const key = options.secureStoreKeyProvider();
-    await forEachStagedTextChunk(
-      stagePath,
-      bodyOffset,
-      (text) => countNormalizer.push(text),
-      key,
-      options.memoryDir
-    );
+    await forEachStagedTextChunk(stagePath, bodyOffset, (text) => countNormalizer.push(text), key, options.memoryDir);
     countNormalizer.finish();
     const category = after.frontmatter.category;
     const connector = after.frontmatter.sourceConnector?.trim() ?? "";
     const encode = (label, value) => `${label} ${value.length} ${value}`;
-    const identityPrefix = [encode("category", category), encode("connector", connector), `content ${normalizedLength} `].join(" ");
-    const identityHash = createHash2("sha256");
+    const identityPrefix = [
+      encode("category", category),
+      encode("connector", connector),
+      `content ${normalizedLength} `
+    ].join(" ");
+    let identityHash = createHash2("sha256");
+    let normalSigmaIdentityHash;
     identityHash.update(identityPrefix);
-    const identityNormalizer = createExplicitContentNormalizer((chunk) => identityHash.update(chunk));
+    const identityNormalizer = createExplicitContentNormalizer({
+      write: (chunk) => {
+        identityHash.update(chunk);
+        normalSigmaIdentityHash?.update(chunk);
+      },
+      beginConditionalSigma: () => {
+        normalSigmaIdentityHash = identityHash.copy().update("\u03C3");
+        identityHash.update("\u03C2");
+      },
+      resolveConditionalSigma: (useFinalSigma) => {
+        if (!useFinalSigma) {
+          if (normalSigmaIdentityHash === void 0) throw new Error("conditional sigma hash state is missing");
+          identityHash = normalSigmaIdentityHash;
+        }
+        normalSigmaIdentityHash = void 0;
+      }
+    });
     await forEachStagedTextChunk(
       stagePath,
       bodyOffset,
@@ -1226,52 +1293,51 @@ 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 mutate = async () => {
-      try {
+    const baseDir = path3.dirname(this.tombstoneBlockedCaptureIndexOptions().stateDir);
+    try {
+      await withRawEntityPageMutation(baseDir, target, async () => {
         await this.runTombstoneBlockedOfflineSyncMutation(
           target,
           prepared.after,
-          () => this.writeStorageSecureFileChunks(target, prepared.chunks),
+          () => this.writeManagedStorageFile(target, () => this.writeStorageSecureFileChunks(target, prepared.chunks)),
           coordinate,
           streamedIdentity
         );
-      } finally {
-        if (prepared.stagePath !== void 0) await unlink2(prepared.stagePath).catch(() => {
-        });
-      }
-    };
-    await mutate();
+      });
+    } finally {
+      if (prepared.stagePath !== void 0) await unlink2(prepared.stagePath).catch(() => {
+      });
+    }
   }
   async writeOfflineSyncFile(filePath, content) {
     const target = this.assertManagedStoragePath(filePath, "storage.writeOfflineSyncFile");
     await this.writeTombstoneBlockedOfflineSyncFile(target, content);
-    await this.requestSyncReconcileIfMemoryPath(target);
+    await this.requestSyncReconcileIfMigrationPath(target);
   }
   async writeOfflineSyncFileChunks(filePath, chunks) {
     const target = this.assertManagedStoragePath(filePath, "storage.writeOfflineSyncFileChunks");
     await this.writeTombstoneBlockedOfflineSyncFileChunks(target, chunks);
-    await this.requestSyncReconcileIfMemoryPath(target);
+    await this.requestSyncReconcileIfMigrationPath(target);
   }
   /**
-   * Replicated bytes are opaque (possibly encrypted) and can carry legacy
-   * entity references a completed migration already renamed (issue #2213) —
-   * but only memory-tier markdown can, so transcript/state/other sync traffic
-   * must not trigger the full-corpus reconcile pass.
+   * Opaque replicated bytes can restore legacy memory references or entity
+   * relationship targets. Other sync traffic must not request reconciliation.
    */
-  async requestSyncReconcileIfMemoryPath(target) {
+  async requestSyncReconcileIfMigrationPath(target) {
     const stateDir = this.tombstoneBlockedCaptureIndexOptions().stateDir;
     if (!pathMayCarryEntityRefs(path3.dirname(stateDir), target)) return;
     await requestEntityCanonicalIdReconcile(stateDir);
   }
-  async deleteOfflineSyncFile(filePath) {
+  async deleteOfflineSyncFile(filePath, deletionMtimeMs) {
     const target = this.assertManagedStoragePath(filePath, "storage.deleteOfflineSyncFile");
-    await this.deleteTombstoneBlockedOfflineSyncFile(target);
+    await this.deleteTombstoneBlockedOfflineSyncFile(target, deletionMtimeMs);
+    await this.requestSyncReconcileIfMigrationPath(target);
   }
-  async deleteTombstoneBlockedOfflineSyncFile(target) {
-    await this.runTombstoneBlockedOfflineSyncMutation(target, null, async () => {
-      await unlink2(target).catch((error) => {
-        if (isErrnoCode(error, "ENOENT")) return;
-        throw error;
+  async deleteTombstoneBlockedOfflineSyncFile(target, deletionMtimeMs) {
+    const stateDir = this.tombstoneBlockedCaptureIndexOptions().stateDir;
+    await withRawEntityPageMutation(path3.dirname(stateDir), target, async () => {
+      await this.runTombstoneBlockedOfflineSyncMutation(target, null, async () => {
+        await this.deleteManagedStorageFile(target, deletionMtimeMs);
       });
     });
   }
@@ -1299,7 +1365,10 @@ export {
   isTombstoneBlockedCaptureWriteLockBusy,
   normalizeExplicitCaptureContent,
   buildExplicitCaptureDedupKey,
+  buildCapturePathLockIdentity,
+  tombstoneBlocked,
+  isQueuedReviewMemory,
   parseTombstoneBlockedOfflineSyncMemory,
   TombstoneBlockedCaptureIndexHost
 };
-//# sourceMappingURL=chunk-RVLJEII5.js.map
+//# sourceMappingURL=chunk-SYUBB3WM.js.map