@remnic/core 9.69.32 → 9.69.34

package/dist/{chunk-GY5WZBA6.js → chunk-S76KRJDG.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-GVG3JYBI.js";
+} from "./chunk-ZMKYCFJ7.js";
 import {
   bumpMemoryCorpusVersionForDir
 } from "./chunk-XCB6QDL6.js";
@@ -15,7 +15,7 @@ import {
 } from "./chunk-C7HJ3NEI.js";
 import {
   excludeSupportPassportPrivateMemories
-} from "./chunk-EEOUMG3J.js";
+} from "./chunk-PWPIERBM.js";
 import {
   RECALL_FALLBACK_DIRS
 } from "./chunk-VS2IYZRU.js";
@@ -765,4 +765,4 @@ export {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
 };
-//# sourceMappingURL=chunk-GY5WZBA6.js.map
+//# sourceMappingURL=chunk-S76KRJDG.js.map

package/dist/{chunk-H272ZPQ3.js → chunk-SHEHQBCG.js}

@@ -66,6 +66,32 @@ function invalidationCommitFingerprint(memory) {
     )
   ).digest("hex");
 }
+function markCasCommittedRevision(err, revision) {
+  if (err instanceof Error) {
+    err.casCommittedRevision = revision;
+  }
+}
+function casCommittedRevisionOf(err) {
+  return err instanceof Error ? err.casCommittedRevision : void 0;
+}
+function nextCasRevisionIso(previous, now = /* @__PURE__ */ new Date()) {
+  const previousMs = previous !== void 0 ? new Date(previous).getTime() : Number.NaN;
+  if (Number.isFinite(previousMs) && now.getTime() <= previousMs) {
+    return new Date(previousMs + 1).toISOString();
+  }
+  return now.toISOString();
+}
+function isSemanticFrontmatterChange(before, after) {
+  return invalidationCommitFingerprint({ content: "", frontmatter: before }) !== invalidationCommitFingerprint({ content: "", frontmatter: after });
+}
+async function withCasCommitReceipt(revision, run) {
+  try {
+    return await run();
+  } catch (err) {
+    markCasCommittedRevision(err, revision);
+    throw err;
+  }
+}
 function isValidInvalidationCommitTimestamp(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= INVALIDATION_COMMIT_MAX_TIMESTAMP_MS;
 }
@@ -75,7 +101,7 @@ function isValidInvalidationCommitFingerprint(value) {
 function isValidMemoryId(value) {
   return typeof value === "string" && value.length > 0 && !value.includes("\0");
 }
-function isValidDeletionRevisionPath(value) {
+function isValidManagedStoragePath(value) {
   return typeof value === "string" && value.length > 0 && !value.includes("\\") && !value.includes("\0") && !path.posix.isAbsolute(value) && path.posix.normalize(value) === value && value !== "." && value !== ".." && !value.startsWith("../");
 }
 function deletionRevisionPathIdentity(value) {
@@ -138,7 +164,7 @@ var DeletionRevisionStore = class {
         throw new Error("Deletion revision metadata is invalid.");
       }
       const entry = rawEntry;
-      if (Object.keys(entry).sort().join(",") !== "mtimeMs,path" || !isValidDeletionRevisionPath(entry.path) || typeof entry.mtimeMs !== "number" || !Number.isFinite(entry.mtimeMs) || entry.mtimeMs < 0 || entry.mtimeMs > DELETION_REVISION_MAX_MTIME_MS || revisions.has(entry.path)) {
+      if (Object.keys(entry).sort().join(",") !== "mtimeMs,path" || !isValidManagedStoragePath(entry.path) || typeof entry.mtimeMs !== "number" || !Number.isFinite(entry.mtimeMs) || entry.mtimeMs < 0 || entry.mtimeMs > DELETION_REVISION_MAX_MTIME_MS || revisions.has(entry.path)) {
         throw new Error("Deletion revision metadata is invalid.");
       }
       const identity = deletionRevisionPathIdentity(entry.path);
@@ -360,7 +386,7 @@ var DeletionRevisionStore = class {
     if (typeof mtimeMs !== "number" || !Number.isFinite(mtimeMs) || mtimeMs < 0 || mtimeMs > DELETION_REVISION_MAX_MTIME_MS) {
       throw new Error("Deletion revision timestamp is invalid.");
     }
-    if (!isValidDeletionRevisionPath(relativePath)) {
+    if (!isValidManagedStoragePath(relativePath)) {
       throw new Error("Deletion revision path is invalid.");
     }
     await this.withDeletionRevisionLock(async (lock) => {
@@ -383,7 +409,7 @@ var DeletionRevisionStore = class {
   }
   async writeManagedStorageFile(filePath, write) {
     const { relativePath } = await this.resolveManagedStoragePath(filePath, "storage.writeManagedStorageFile");
-    if (!isValidDeletionRevisionPath(relativePath)) {
+    if (!isValidManagedStoragePath(relativePath)) {
       throw new Error("Deletion revision path is invalid.");
     }
     await this.withDeletionRevisionLock(async (lock) => {
@@ -415,7 +441,7 @@ var DeletionRevisionStore = class {
         if (isErrnoCode(error, "ENOENT")) return false;
         throw error;
       }
-      if (!isValidDeletionRevisionPath(relativePath)) {
+      if (!isValidManagedStoragePath(relativePath)) {
         throw new Error("Deletion revision path is invalid.");
       }
       const revision = deletionMtimeMs === null ? void 0 : deletionMtimeMs ?? Date.now();
@@ -582,6 +608,7 @@ 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);
@@ -595,19 +622,51 @@ async function runTombstoneBlockedMutation(host, mutation) {
         }
       }
       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 (rebuildMarker) {
+        if (transaction) {
           try {
-            await host.discardWrite(rebuildMarker);
-          } catch (cleanupError) {
-            host.markUntrusted();
-            host.logWarning(`storage.tombstoneBlocked failed to clear write marker: ${cleanupError}`);
+            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);
@@ -620,7 +679,7 @@ async function runTombstoneBlockedMutation(host, mutation) {
       await mutation.updateIndex(rebuildMarker, currentBlocked && current !== null ? current : void 0);
     };
     await host.withCaptureWriteLock(mutate, lockIdentity);
-    if (retryIdentity === void 0) return;
+    if (retryIdentity === void 0) return mintedRevision;
     const identities = Array.isArray(lockIdentity) ? [...lockIdentity, retryIdentity] : [lockIdentity, retryIdentity];
     lockIdentity = [...new Set(identities)];
   }
@@ -1056,6 +1115,17 @@ var TombstoneBlockedCaptureIndex = class {
   async rebuildAfterInvalidation(ownedMarker) {
     await this.failOpen("invalidateMemory", () => this.rebuildIfLoaded(ownedMarker));
   }
+  /**
+   * Drop an already-committed write marker without re-reading the corpus. The
+   * offline-sync mutation path commits its marker around the file write, then
+   * must clear it even when the write cannot have changed the blocked key set
+   * (neither side tombstone-blocked) — otherwise the marker lingers until some
+   * later rebuild clears it. Mirrors the tail of `add`/`sync`.
+   */
+  async clearCommittedWriteMarker(rebuildMarker) {
+    await this.clearRebuildRequired([rebuildMarker]);
+    await this.setAuthoritative(true);
+  }
   async syncUpdatedMemory(before, frontmatter, content, rebuildMarker) {
     await this.failOpen("updateMemory", () => this.sync(before, { ...before, frontmatter, content }, rebuildMarker));
   }
@@ -1192,6 +1262,15 @@ function parseTombstoneBlockedOfflineSyncMemory(filePath, content, memoryDir, pa
 }
 var TombstoneBlockedCaptureIndexHost = class {
   tombstoneBlockedCaptureIndex = null;
+  /** #2813 (P1 C, #2807): reserve the target's next durable CAS revision
+   * token as a two-phase receipt transaction — a PENDING write-ahead
+   * marker under the mutation's path lock, published COMMITTED only after
+   * the durable file write lands. Receipt identity lives in the per-target
+   * sidecar, never in public `frontmatter.updated`. The default host keeps
+   * no receipt identity; StorageManager records it. */
+  async beginDurableMemoryRevision(_pathname, _expectedContent) {
+    return void 0;
+  }
   async writeStorageSecureFileChunks(filePath, chunks) {
     const options = this.tombstoneBlockedCaptureIndexOptions();
     await writeMaybeEncryptedFileFromChunks(
@@ -1235,7 +1314,7 @@ var TombstoneBlockedCaptureIndexHost = class {
   async withTombstoneBlockedCaptureWriteLockAndHashes(task, identity, identityHashes) {
     return await this.getTombstoneBlockedCaptureIndex().withCaptureWriteLockAndHashes(task, identity, identityHashes);
   }
-  async writeTombstoneBlockedMutation(blocked, pathname, fileContent, identity, updateIndex, beforeIndexUpdate, coordinate = false) {
+  async writeTombstoneBlockedMutation(blocked, pathname, fileContent, identity, updateIndex, beforeIndexUpdate, coordinate = false, shouldMintRevision) {
     const host = {
       readCurrent: () => this.readMemoryByPath(pathname),
       isBlocked: (memory) => this.isTombstoneBlockedMemory(memory),
@@ -1247,16 +1326,18 @@ var TombstoneBlockedCaptureIndexHost = class {
       markUntrusted: () => this.getTombstoneBlockedCaptureIndex().markUntrusted(),
       writeStorageSecureFile: (target, content) => this.writeStorageSecureFile(target, content),
       withCaptureWriteLock: (task, lockIdentity) => this.withTombstoneBlockedCaptureWriteLock(task, lockIdentity),
-      logWarning: (message) => log.warn(message)
+      logWarning: (message) => log.warn(message),
+      beginDurableMemoryRevision: (targetPath, expectedContent) => this.beginDurableMemoryRevision(targetPath, expectedContent)
     };
-    await runTombstoneBlockedMutation(host, {
+    return await runTombstoneBlockedMutation(host, {
       blocked,
       pathname,
       fileContent,
       identity,
       updateIndex,
       beforeIndexUpdate,
-      coordinate
+      coordinate,
+      shouldMintRevision
     });
   }
   async writeTombstoneBlockedMemory(pathname, fileContent, frontmatter, content, beforeIndexUpdate) {
@@ -1325,7 +1406,7 @@ var TombstoneBlockedCaptureIndexHost = class {
     }
   }
   async writeTombstoneBlockedUpdate(before, fileContent, frontmatter, content, beforeIndexUpdate) {
-    await this.writeTombstoneBlockedMutation(
+    return await this.writeTombstoneBlockedMutation(
       tombstoneBlocked(before.frontmatter) || tombstoneBlocked(frontmatter),
       before.path,
       fileContent,
@@ -1341,11 +1422,12 @@ var TombstoneBlockedCaptureIndexHost = class {
         rebuildMarker
       ),
       beforeIndexUpdate,
-      true
+      true,
+      () => true
     );
   }
   async writeTombstoneBlockedFrontmatter(before, fileContent, frontmatter, beforeIndexUpdate) {
-    await this.writeTombstoneBlockedMutation(
+    return await this.writeTombstoneBlockedMutation(
       tombstoneBlocked(before.frontmatter) || tombstoneBlocked(frontmatter),
       before.path,
       fileContent,
@@ -1356,7 +1438,8 @@ var TombstoneBlockedCaptureIndexHost = class {
       ],
       (rebuildMarker, current) => this.getTombstoneBlockedCaptureIndex().syncUpdatedFrontmatter(current ?? before, frontmatter, rebuildMarker),
       beforeIndexUpdate,
-      true
+      true,
+      (current) => isSemanticFrontmatterChange((current ?? before).frontmatter, frontmatter)
     );
   }
   isTombstoneBlockedMemory(memory) {
@@ -1390,14 +1473,23 @@ var TombstoneBlockedCaptureIndexHost = class {
     if (beforeIdentity !== incomingIdentity) return false;
     return streamedIdentity ? isDeepStrictEqual(before.frontmatter, incoming.frontmatter) : before.content === incoming.content && isDeepStrictEqual(before.frontmatter, incoming.frontmatter);
   }
-  async invalidateAfterOfflineSyncMutation(filePath, ownedMarker, archiveChanged = true) {
+  async invalidateAfterOfflineSyncMutation(filePath, ownedMarker, archiveChanged = true, blockedKeySetMayHaveChanged = true) {
     this.invalidateAllMemoriesCache();
     this.invalidateKnowledgeIndexCache();
     this.markFactHashIndexNotAuthoritative();
     if (filePath.includes(`${path4.sep}cold${path4.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
-    await this.rebuildTombstoneBlockedCaptureAfterInvalidationForPath(filePath, ownedMarker);
+    if (blockedKeySetMayHaveChanged) {
+      await this.rebuildTombstoneBlockedCaptureAfterInvalidationForPath(filePath, ownedMarker);
+    } else if (ownedMarker !== void 0) {
+      try {
+        await this.getTombstoneBlockedCaptureIndex().clearCommittedWriteMarker(ownedMarker);
+      } catch (err) {
+        this.getTombstoneBlockedCaptureIndex().markUntrusted();
+        log.warn(`storage.offlineSyncFile committed write succeeded; marker cleanup failed: ${err}`);
+      }
+    }
     if (filePath.includes(`${path4.sep}artifacts${path4.sep}`)) {
       this.bumpArtifactWriteVersion();
     }
@@ -1544,7 +1636,12 @@ var TombstoneBlockedCaptureIndexHost = class {
               log.warn(`storage.offlineSyncFile committed write marker failed: ${err}`);
             }
           }
-          await this.invalidateAfterOfflineSyncMutation(target, marker, changed !== false);
+          await this.invalidateAfterOfflineSyncMutation(
+            target,
+            marker,
+            changed !== false,
+            this.isTombstoneBlockedMemory(current) || this.isTombstoneBlockedMemory(after)
+          );
         } catch (err) {
           if (marker && !durable) {
             try {
@@ -1805,6 +1902,10 @@ var TombstoneBlockedCaptureIndexHost = class {
 
 export {
   invalidationCommitFingerprint,
+  casCommittedRevisionOf,
+  nextCasRevisionIso,
+  withCasCommitReceipt,
+  isValidManagedStoragePath,
   DeletionRevisionStore,
   isTombstoneBlockedCaptureWriteLockBusy,
   normalizeExplicitCaptureContent,
@@ -1815,4 +1916,4 @@ export {
   parseTombstoneBlockedOfflineSyncMemory,
   TombstoneBlockedCaptureIndexHost
 };
-//# sourceMappingURL=chunk-H272ZPQ3.js.map
+//# sourceMappingURL=chunk-SHEHQBCG.js.map