@remnic/core 10.0.92 → 10.0.94

package/dist/chunk-FHGWKODN.js

@@ -1,2300 +0,0 @@
-import {
-  pathMayCarryEntityRefs,
-  requestEntityCanonicalIdReconcile,
-  withRawEntityPageMutation
-} from "./chunk-IAYUTGF2.js";
-import {
-  TombstoneBlockedCaptureWriteLock,
-  buildCapturePathLockIdentity,
-  buildExplicitCaptureDedupKey,
-  captureIdentityHash,
-  isQueuedReviewMemory,
-  runTombstoneBlockedMutation,
-  tombstoneBlocked
-} from "./chunk-Y33KJ556.js";
-import {
-  bumpArchiveMutationForPath
-} from "./chunk-W5BIQOAJ.js";
-import {
-  markProjectedMemoryPathInvalid
-} from "./chunk-AL3UYZ5N.js";
-import {
-  CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS,
-  ContentHashIndex
-} from "./chunk-UDKWFDV2.js";
-import {
-  withHeldFileLock
-} from "./chunk-EBV6VXKF.js";
-import {
-  resolveSafeStoragePath
-} from "./chunk-LDPPTPO5.js";
-import {
-  readMaybeEncryptedFileFromChunks,
-  writeMaybeEncryptedFileFromChunks
-} from "./chunk-EYGOM6AI.js";
-import {
-  RECALL_FALLBACK_DIRS
-} from "./chunk-VS2IYZRU.js";
-import {
-  isErrnoCode
-} from "./chunk-KNA3BXXL.js";
-import {
-  log
-} from "./chunk-3WCASNQZ.js";
-
-// src/storage/deletion-revision-store.ts
-import { createHash, randomUUID } from "crypto";
-import { lstat, mkdir, open, readFile, rename, unlink } from "fs/promises";
-import path from "path";
-var DELETION_REVISION_MAX_MTIME_MS = 864e13;
-var DELETION_REVISION_LOCK_STALE_MS = 6e4;
-var DELETION_REVISION_LOCK_MAX_WAIT_MS = 12e4;
-var INVALIDATION_COMMIT_MAX_TIMESTAMP_MS = 864e13;
-var INVALIDATION_PROOF_QUARANTINE_MAX_IDS = 1024;
-function canonicalizeInvalidationEvidence(value) {
-  if (Array.isArray(value)) return value.map((item) => canonicalizeInvalidationEvidence(item));
-  if (value && typeof value === "object") {
-    const result = {};
-    for (const key of Object.keys(value).sort()) {
-      result[key] = canonicalizeInvalidationEvidence(value[key]);
-    }
-    return result;
-  }
-  return value;
-}
-function invalidationCommitFingerprint(memory) {
-  const frontmatter = { ...memory.frontmatter };
-  delete frontmatter.accessCount;
-  delete frontmatter.lastAccessed;
-  return createHash("sha256").update(
-    JSON.stringify(
-      canonicalizeInvalidationEvidence({
-        content: memory.content,
-        frontmatter
-      })
-    )
-  ).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;
-}
-function isValidInvalidationCommitFingerprint(value) {
-  return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
-}
-function isValidMemoryId(value) {
-  return typeof value === "string" && value.length > 0 && !value.includes("\0");
-}
-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) {
-  return value.normalize("NFC").toUpperCase().toLowerCase();
-}
-var DeletionRevisionStore = class {
-  options;
-  invalidationProofQuarantine = /* @__PURE__ */ new Set();
-  invalidationProofQuarantineFull = false;
-  invalidationProofQuarantineFullAt = null;
-  constructor(options) {
-    this.options = options;
-  }
-  quarantineInvalidationProof(memoryId) {
-    if (this.invalidationProofQuarantineFull) {
-      const nextBoundary = Date.now() + 1;
-      this.invalidationProofQuarantineFullAt = Math.max(
-        this.invalidationProofQuarantineFullAt ?? 0,
-        nextBoundary
-      );
-      return;
-    }
-    if (this.invalidationProofQuarantine.has(memoryId)) return;
-    if (this.invalidationProofQuarantine.size >= INVALIDATION_PROOF_QUARANTINE_MAX_IDS) {
-      this.invalidationProofQuarantineFull = true;
-      this.invalidationProofQuarantineFullAt = Date.now() + 1;
-      return;
-    }
-    this.invalidationProofQuarantine.add(memoryId);
-  }
-  async resolveConfiguredStoragePath(targetPath) {
-    const baseDir = path.resolve(this.options.baseDir);
-    const relativePath = path.relative(baseDir, path.resolve(targetPath));
-    return resolveSafeStoragePath(baseDir, relativePath);
-  }
-  async resolveManagedStoragePath(filePath, method) {
-    const assertedPath = this.options.assertManagedStoragePath(filePath, method);
-    const target = await this.resolveConfiguredStoragePath(assertedPath);
-    const relativePath = path.relative(path.resolve(this.options.baseDir), target).split(path.sep).join("/");
-    return { target, relativePath };
-  }
-  parseDeletionRevisionMetadata(raw) {
-    let parsed;
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      throw new Error("Deletion revision metadata is invalid.");
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new Error("Deletion revision metadata is invalid.");
-    }
-    const root = parsed;
-    if (Object.keys(root).sort().join(",") !== "deletions,version" || root.version !== 1 || !Array.isArray(root.deletions)) {
-      throw new Error("Deletion revision metadata is invalid.");
-    }
-    const revisions = /* @__PURE__ */ new Map();
-    const pathByIdentity = /* @__PURE__ */ new Map();
-    for (const rawEntry of root.deletions) {
-      if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
-        throw new Error("Deletion revision metadata is invalid.");
-      }
-      const entry = rawEntry;
-      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);
-      if (pathByIdentity.has(identity)) {
-        throw new Error("Deletion revision metadata is invalid.");
-      }
-      pathByIdentity.set(identity, entry.path);
-      revisions.set(entry.path, entry.mtimeMs);
-    }
-    return new Map([...revisions.entries()].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0));
-  }
-  async readDeletionRevisionMetadata() {
-    const metadataPath = await this.resolveConfiguredStoragePath(this.options.deletionRevisionMetadataPath);
-    let raw;
-    try {
-      raw = await readFile(metadataPath, "utf8");
-    } catch (error) {
-      if (isErrnoCode(error, "ENOENT")) return /* @__PURE__ */ new Map();
-      throw new Error("Deletion revision metadata is unavailable.");
-    }
-    return this.parseDeletionRevisionMetadata(raw);
-  }
-  async writeDeletionRevisionMetadata(revisions, lock) {
-    const metadataPath = await this.resolveConfiguredStoragePath(this.options.deletionRevisionMetadataPath);
-    const deletions = [...revisions.entries()].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([entryPath, mtimeMs]) => ({ path: entryPath, mtimeMs }));
-    const metadata = { version: 1, deletions };
-    const temporaryPath = await this.resolveConfiguredStoragePath(
-      `${metadataPath}.${process.pid}.${randomUUID()}.tmp`
-    );
-    let handle = null;
-    try {
-      handle = await open(temporaryPath, "wx", 384);
-      await handle.writeFile(`${JSON.stringify(metadata)}
-`, "utf8");
-      await handle.sync();
-      await handle.close();
-      handle = null;
-      if (!await lock.refresh()) {
-        throw new Error("Deletion revision metadata lock was lost.");
-      }
-      const renameTarget = await this.resolveConfiguredStoragePath(this.options.deletionRevisionMetadataPath);
-      await rename(temporaryPath, renameTarget);
-    } finally {
-      if (handle !== null) {
-        await handle.close().catch((error) => {
-          log.warn("failed to close deletion revision metadata temporary file", error);
-        });
-      }
-      const cleanupPath = await this.resolveConfiguredStoragePath(temporaryPath).catch((error) => {
-        log.warn("failed to resolve deletion revision metadata temporary file for cleanup", error);
-        return null;
-      });
-      if (cleanupPath !== null) {
-        await unlink(cleanupPath).catch((error) => {
-          if (!isErrnoCode(error, "ENOENT")) {
-            log.warn("failed to clean up deletion revision metadata temporary file", error);
-          }
-        });
-      }
-    }
-  }
-  async withDeletionRevisionLock(task) {
-    const lockPath = await this.resolveConfiguredStoragePath(this.options.deletionRevisionLockPath);
-    return withHeldFileLock(
-      lockPath,
-      {
-        staleMs: DELETION_REVISION_LOCK_STALE_MS,
-        maxWaitMs: DELETION_REVISION_LOCK_MAX_WAIT_MS
-      },
-      async (acquired, lock) => {
-        if (!acquired) throw new Error("Deletion revision metadata lock is unavailable.");
-        return task(lock);
-      }
-    );
-  }
-  async readDeletionRevisions() {
-    return this.withDeletionRevisionLock(async () => this.readDeletionRevisionMetadata());
-  }
-  parseInvalidationCommitMetadata(raw) {
-    let parsed;
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      throw new Error("Invalidation commit metadata is invalid.");
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new Error("Invalidation commit metadata is invalid.");
-    }
-    const root = parsed;
-    if (Object.keys(root).sort().join(",") !== "commits,version" || root.version !== 1 || !Array.isArray(root.commits)) {
-      throw new Error("Invalidation commit metadata is invalid.");
-    }
-    const commits = /* @__PURE__ */ new Map();
-    for (const rawEntry of root.commits) {
-      if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
-        throw new Error("Invalidation commit metadata is invalid.");
-      }
-      const entry = rawEntry;
-      if (Object.keys(entry).sort().join(",") !== "committedAt,fingerprint,memoryId" || !isValidMemoryId(entry.memoryId) || !isValidInvalidationCommitFingerprint(entry.fingerprint) || !isValidInvalidationCommitTimestamp(entry.committedAt) || commits.has(entry.memoryId)) {
-        throw new Error("Invalidation commit metadata is invalid.");
-      }
-      commits.set(entry.memoryId, {
-        fingerprint: entry.fingerprint,
-        committedAt: entry.committedAt
-      });
-    }
-    return commits;
-  }
-  async readInvalidationCommitMetadata() {
-    const metadataPath = await this.resolveConfiguredStoragePath(this.options.invalidationCommitMetadataPath);
-    let raw;
-    try {
-      raw = await readFile(metadataPath, "utf8");
-    } catch (error) {
-      if (isErrnoCode(error, "ENOENT")) return /* @__PURE__ */ new Map();
-      throw new Error("Invalidation commit metadata is unavailable.");
-    }
-    return this.parseInvalidationCommitMetadata(raw);
-  }
-  async writeInvalidationCommitMetadata(commits, lock) {
-    const metadataPath = await this.resolveConfiguredStoragePath(this.options.invalidationCommitMetadataPath);
-    const entries = [...commits.entries()].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([memoryId, value]) => ({
-      memoryId,
-      fingerprint: value.fingerprint,
-      committedAt: value.committedAt
-    }));
-    const metadata = { version: 1, commits: entries };
-    const temporaryPath = await this.resolveConfiguredStoragePath(
-      `${metadataPath}.${process.pid}.${randomUUID()}.tmp`
-    );
-    const metadataDir = await this.resolveConfiguredStoragePath(path.dirname(metadataPath));
-    let handle = null;
-    let renamed = false;
-    try {
-      await mkdir(metadataDir, { recursive: true });
-      handle = await open(temporaryPath, "wx", 384);
-      await handle.writeFile(`${JSON.stringify(metadata)}
-`, "utf8");
-      await handle.sync();
-      await handle.close();
-      handle = null;
-      if (!await lock.refresh()) {
-        throw new Error("Invalidation commit metadata lock was lost.");
-      }
-      const renameTarget = await this.resolveConfiguredStoragePath(this.options.invalidationCommitMetadataPath);
-      await rename(temporaryPath, renameTarget);
-      renamed = true;
-    } finally {
-      if (handle !== null) {
-        await handle.close().catch((error) => {
-          log.warn("failed to close invalidation commit metadata temporary file", error);
-        });
-      }
-      const cleanupPath = await this.resolveConfiguredStoragePath(temporaryPath).catch((error) => {
-        log.warn("failed to resolve invalidation commit metadata temporary file for cleanup", error);
-        return null;
-      });
-      if (cleanupPath !== null) {
-        await unlink(cleanupPath).catch((error) => {
-          if (!isErrnoCode(error, "ENOENT")) {
-            log.warn(
-              `failed to clean up invalidation commit metadata temporary file after ${renamed ? "commit" : "failure"}`,
-              error
-            );
-          }
-        });
-      }
-    }
-  }
-  async hasCommittedInvalidation(memory) {
-    const memoryId = memory.frontmatter.id;
-    const fingerprint = invalidationCommitFingerprint(memory);
-    return this.withDeletionRevisionLock(async () => {
-      const entry = (await this.readInvalidationCommitMetadata()).get(memoryId);
-      if (entry?.fingerprint !== fingerprint) return false;
-      if (this.invalidationProofQuarantine.has(memoryId)) return false;
-      if (!this.invalidationProofQuarantineFull) return true;
-      const fullAt = this.invalidationProofQuarantineFullAt;
-      return fullAt !== null && entry.committedAt >= fullAt;
-    });
-  }
-  async recordCommittedInvalidation(memory) {
-    const fingerprint = invalidationCommitFingerprint(memory);
-    await this.withDeletionRevisionLock(async (lock) => {
-      const fullAt = this.invalidationProofQuarantineFullAt;
-      const committedAt = fullAt === null ? Date.now() : Math.max(Date.now(), fullAt + 1);
-      const commits = await this.readInvalidationCommitMetadata();
-      commits.set(memory.frontmatter.id, {
-        fingerprint,
-        committedAt
-      });
-      await this.writeInvalidationCommitMetadata(commits, lock);
-      this.invalidationProofQuarantine.delete(memory.frontmatter.id);
-    });
-  }
-  async clearCommittedInvalidation(memory) {
-    const memoryId = memory.frontmatter.id;
-    this.quarantineInvalidationProof(memoryId);
-    const fingerprint = invalidationCommitFingerprint(memory);
-    let cleared = false;
-    try {
-      await this.withDeletionRevisionLock(async (lock) => {
-        const commits = await this.readInvalidationCommitMetadata();
-        const current = commits.get(memoryId);
-        if (current?.fingerprint !== fingerprint) return;
-        commits.delete(memoryId);
-        await this.writeInvalidationCommitMetadata(commits, lock);
-      });
-      cleared = true;
-    } finally {
-      if (cleared) this.invalidationProofQuarantine.delete(memoryId);
-    }
-  }
-  async recordReplicatedDeletionRevision(filePath, mtimeMs) {
-    const { relativePath } = await this.resolveManagedStoragePath(
-      filePath,
-      "storage.recordReplicatedDeletionRevision"
-    );
-    if (typeof mtimeMs !== "number" || !Number.isFinite(mtimeMs) || mtimeMs < 0 || mtimeMs > DELETION_REVISION_MAX_MTIME_MS) {
-      throw new Error("Deletion revision timestamp is invalid.");
-    }
-    if (!isValidManagedStoragePath(relativePath)) {
-      throw new Error("Deletion revision path is invalid.");
-    }
-    await this.withDeletionRevisionLock(async (lock) => {
-      const revisions = await this.readDeletionRevisionMetadata();
-      const identity = deletionRevisionPathIdentity(relativePath);
-      let existingPath;
-      for (const candidatePath of revisions.keys()) {
-        if (deletionRevisionPathIdentity(candidatePath) === identity) {
-          existingPath = candidatePath;
-          break;
-        }
-      }
-      const existingMtimeMs = existingPath === void 0 ? void 0 : revisions.get(existingPath);
-      if (existingMtimeMs !== void 0 && existingMtimeMs >= mtimeMs) return;
-      const updated = new Map(revisions);
-      if (existingPath !== void 0) updated.delete(existingPath);
-      updated.set(relativePath, mtimeMs);
-      await this.writeDeletionRevisionMetadata(updated, lock);
-    });
-  }
-  async writeManagedStorageFile(filePath, write) {
-    const { relativePath } = await this.resolveManagedStoragePath(filePath, "storage.writeManagedStorageFile");
-    if (!isValidManagedStoragePath(relativePath)) {
-      throw new Error("Deletion revision path is invalid.");
-    }
-    await this.withDeletionRevisionLock(async (lock) => {
-      const before = await this.readDeletionRevisionMetadata();
-      const identity = deletionRevisionPathIdentity(relativePath);
-      const existingPath = [...before.keys()].find(
-        (candidatePath) => deletionRevisionPathIdentity(candidatePath) === identity
-      );
-      await write();
-      if (existingPath === void 0) return;
-      const updated = new Map(before);
-      updated.delete(existingPath);
-      await this.writeDeletionRevisionMetadata(updated, lock);
-    });
-  }
-  async deleteManagedStorageFile(filePath, deletionMtimeMs) {
-    const { target, relativePath } = await this.resolveManagedStoragePath(
-      filePath,
-      "storage.deleteManagedStorageFile"
-    );
-    if (deletionMtimeMs !== void 0 && deletionMtimeMs !== null && (typeof deletionMtimeMs !== "number" || !Number.isFinite(deletionMtimeMs) || deletionMtimeMs < 0 || deletionMtimeMs > DELETION_REVISION_MAX_MTIME_MS)) {
-      throw new Error("Deletion revision timestamp is invalid.");
-    }
-    return this.withDeletionRevisionLock(async (lock) => {
-      const safeTarget = await this.resolveConfiguredStoragePath(target);
-      try {
-        await lstat(safeTarget);
-      } catch (error) {
-        if (isErrnoCode(error, "ENOENT")) return false;
-        throw error;
-      }
-      if (!isValidManagedStoragePath(relativePath)) {
-        throw new Error("Deletion revision path is invalid.");
-      }
-      const revision = deletionMtimeMs === null ? void 0 : deletionMtimeMs ?? Date.now();
-      const before = await this.readDeletionRevisionMetadata();
-      const identity = deletionRevisionPathIdentity(relativePath);
-      let existingPath;
-      for (const candidatePath of before.keys()) {
-        if (deletionRevisionPathIdentity(candidatePath) === identity) {
-          existingPath = candidatePath;
-          break;
-        }
-      }
-      const existing = existingPath === void 0 ? void 0 : before.get(existingPath);
-      const changed = existingPath !== void 0 && existingPath !== relativePath || (revision === void 0 ? existing !== void 0 : existing !== revision);
-      if (changed) {
-        const updated = new Map(before);
-        if (existingPath !== void 0) updated.delete(existingPath);
-        if (revision !== void 0) updated.set(relativePath, revision);
-        await this.writeDeletionRevisionMetadata(updated, lock);
-      }
-      try {
-        const unlinkTarget = await this.resolveConfiguredStoragePath(target);
-        await unlink(unlinkTarget);
-        return true;
-      } catch (error) {
-        if (changed) await this.writeDeletionRevisionMetadata(before, lock);
-        if (isErrnoCode(error, "ENOENT")) return false;
-        throw error;
-      }
-    });
-  }
-};
-
-// src/storage/cas-revision-store.ts
-import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
-import { mkdir as mkdir2, open as open2, readFile as readFile2, rename as rename2, unlink as unlink2 } from "fs/promises";
-import path2 from "path";
-var ACCESS_TELEMETRY_FRONTMATTER_KEY = /^(?:accessCount|lastAccessed):/;
-function canonicalSemanticFileText(raw) {
-  const lines = raw.split("\n");
-  if (lines[0] !== "---") return raw;
-  const closing = lines.indexOf("---", 1);
-  if (closing === -1) return raw;
-  const frontmatter = lines.slice(1, closing).filter((line) => !ACCESS_TELEMETRY_FRONTMATTER_KEY.test(line));
-  return [...lines.slice(0, 1), ...frontmatter, ...lines.slice(closing)].join("\n");
-}
-var CAS_REVISION_LOCK_STALE_MS = 6e4;
-var CAS_REVISION_LOCK_MAX_WAIT_MS = 12e4;
-var SHA256_HEX = /^[0-9a-f]{64}$/;
-function isDigestOrNullOrUndefined(value) {
-  if (value === void 0 || value === null) return true;
-  return typeof value === "string" && SHA256_HEX.test(value);
-}
-function pendingWriteHasLanded(view) {
-  if (view.writeLanded === true) return true;
-  if (view.writeLanded === false) return false;
-  return view.expectedDigest !== void 0;
-}
-var CasRevisionStore = class {
-  baseDir;
-  legacyMetadataPath;
-  constructor(baseDir) {
-    this.baseDir = baseDir;
-    this.legacyMetadataPath = path2.join(baseDir, ".offline-sync", "cas-revisions.v1.json");
-  }
-  parseCasRevisionMetadata(raw) {
-    let parsed;
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      throw new Error("CAS revision metadata is invalid.");
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new Error("CAS revision metadata is invalid.");
-    }
-    const root = parsed;
-    if (Object.keys(root).sort().join(",") !== "revisions,version" || root.version !== 1 || !Array.isArray(root.revisions)) {
-      throw new Error("CAS revision metadata is invalid.");
-    }
-    const revisions = /* @__PURE__ */ new Map();
-    for (const rawEntry of root.revisions) {
-      if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
-        throw new Error("CAS revision metadata is invalid.");
-      }
-      const entry = rawEntry;
-      if (Object.keys(entry).sort().join(",") !== "path,revision" || typeof entry.path !== "string" || !isValidManagedStoragePath(entry.path) || typeof entry.revision !== "string" || entry.revision.length === 0 || revisions.has(entry.path)) {
-        throw new Error("CAS revision metadata is invalid.");
-      }
-      revisions.set(entry.path, entry.revision);
-    }
-    return revisions;
-  }
-  async readLegacyMetadata() {
-    const baseDir = path2.resolve(this.baseDir);
-    const legacyPath = await resolveSafeStoragePath(baseDir, path2.relative(baseDir, this.legacyMetadataPath));
-    let raw;
-    try {
-      raw = await readFile2(legacyPath, "utf8");
-    } catch (error) {
-      if (isErrnoCode(error, "ENOENT")) return /* @__PURE__ */ new Map();
-      throw new Error("CAS revision metadata is unavailable.");
-    }
-    return this.parseCasRevisionMetadata(raw);
-  }
-  /** #2813 (P1 A): every sidecar path is resolved (and symlink-audited)
-   * inside the memory root before it is used for a lock, read, rename, or
-   * unlink. A symlinked `.offline-sync`, `.offline-sync/cas-revisions`, or
-   * shard file makes this throw, so no sidecar traffic can follow a link
-   * out of the root. */
-  async getSafeShardInfo(relativePath) {
-    const baseDir = path2.resolve(this.baseDir);
-    const hash = createHash2("sha256").update(relativePath).digest("hex");
-    const shardPath = await resolveSafeStoragePath(baseDir, ".offline-sync", "cas-revisions", `${hash}.json`);
-    const lockPath = await resolveSafeStoragePath(baseDir, ".offline-sync", "cas-revisions", `${hash}.json.lock`);
-    return { shardPath, lockPath };
-  }
-  async readShardView(shardPath, relativePath) {
-    let raw;
-    try {
-      raw = await readFile2(shardPath, "utf8");
-    } catch (error) {
-      if (isErrnoCode(error, "ENOENT")) return { kind: "missing" };
-      throw error;
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      throw new Error("CAS revision shard is unreadable.");
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return { kind: "foreign" };
-    }
-    const root = parsed;
-    if (root.state !== void 0) {
-      if (root.version !== 1 || typeof root.path !== "string" || typeof root.revision !== "string" || root.revision.length === 0 || root.state !== "pending" && root.state !== "committed" || root.previous !== void 0 && (typeof root.previous !== "string" || root.previous.length === 0) || !isDigestOrNullOrUndefined(root.baselineDigest) || !isDigestOrNullOrUndefined(root.expectedDigest) || root.writeLanded !== void 0 && typeof root.writeLanded !== "boolean") {
-        throw new Error("CAS revision shard is unreadable.");
-      }
-      const foreign = root.path !== relativePath;
-      const committedDigest = typeof root.committedDigest === "string" ? root.committedDigest : void 0;
-      const committedSemanticFingerprint = typeof root.committedSemanticFingerprint === "string" ? root.committedSemanticFingerprint : void 0;
-      return root.state === "pending" ? {
-        kind: "pending",
-        revision: root.revision,
-        previous: root.previous,
-        foreign,
-        baselineDigest: root.baselineDigest,
-        expectedDigest: root.expectedDigest,
-        ...typeof root.writeLanded === "boolean" ? { writeLanded: root.writeLanded } : {}
-      } : {
-        kind: "committed",
-        revision: root.revision,
-        committedDigest,
-        committedSemanticFingerprint,
-        foreign
-      };
-    }
-    if (root.version === 1 && root.path === relativePath && typeof root.revision === "string" && root.revision.length > 0) {
-      const committedDigest = typeof root.committedDigest === "string" ? root.committedDigest : void 0;
-      const committedSemanticFingerprint = typeof root.committedSemanticFingerprint === "string" ? root.committedSemanticFingerprint : void 0;
-      return {
-        kind: "committed",
-        revision: root.revision,
-        committedDigest,
-        committedSemanticFingerprint,
-        foreign: false
-      };
-    }
-    return { kind: "foreign" };
-  }
-  async readStandingRevision(relativePath) {
-    try {
-      return await this.readStandingRevisionStrict(relativePath);
-    } catch (error) {
-      log.warn(`CasRevisionStore failed to read standing revision for ${relativePath}: ${error}`);
-      return void 0;
-    }
-  }
-  /** #2813 (P1 A): strict core of {@link readStandingRevision}. Returns
-   * undefined ONLY when no receipt exists for the target — the shard is
-   * absent (or names another target) and the legacy metadata holds no
-   * entry. THROWS when the standing receipt cannot be determined: an
-   * unreadable or corrupt shard, a PENDING reservation awaiting
-   * finalization or recovery, or unreadable or invalid legacy metadata.
-   * Fail-open callers collapse the throw into undefined; truthful callers
-   * ({@link readRevisionStatus}) report `unavailable` so a transaction can
-   * refuse instead of mistaking the failure for absence. */
-  async readStandingRevisionStrict(relativePath) {
-    const { shardPath } = await this.getSafeShardInfo(relativePath);
-    const view = await this.readShardView(shardPath, relativePath);
-    if (view.kind === "pending") {
-      throw new Error(
-        `CAS revision receipt for ${relativePath} is pending finalization (recovery needed).`
-      );
-    }
-    if (view.kind === "committed" && !view.foreign) {
-      return {
-        revision: view.revision,
-        committedDigest: view.committedDigest,
-        committedSemanticFingerprint: view.committedSemanticFingerprint
-      };
-    }
-    const legacyMap = await this.readLegacyMetadata();
-    const legacyRev = legacyMap.get(relativePath);
-    return legacyRev === void 0 ? void 0 : { revision: legacyRev };
-  }
-  async writeShard(shardPath, relativePath, revision, lock, state, previous, evidence) {
-    let payload;
-    if (state === "committed") {
-      payload = { version: 1, path: relativePath, revision, state };
-      if (evidence?.committedDigest !== void 0) {
-        payload.committedDigest = evidence.committedDigest;
-      }
-      if (evidence?.committedSemanticFingerprint !== void 0) {
-        payload.committedSemanticFingerprint = evidence.committedSemanticFingerprint;
-      }
-    } else {
-      payload = { version: 1, path: relativePath, revision, state };
-      if (previous !== void 0) payload.previous = previous;
-      if (evidence !== void 0) {
-        if (evidence.baselineDigest !== void 0) payload.baselineDigest = evidence.baselineDigest;
-        if (evidence.expectedDigest !== void 0) payload.expectedDigest = evidence.expectedDigest;
-        if (evidence.writeLanded !== void 0) payload.writeLanded = evidence.writeLanded;
-      }
-    }
-    const baseDir = path2.resolve(this.baseDir);
-    const temporaryPath = await resolveSafeStoragePath(
-      baseDir,
-      path2.relative(baseDir, `${shardPath}.${process.pid}.${randomUUID2()}.tmp`)
-    );
-    let handle = null;
-    try {
-      await mkdir2(path2.dirname(shardPath), { recursive: true });
-      handle = await open2(temporaryPath, "wx", 384);
-      await handle.writeFile(`${JSON.stringify(payload)}
-`, "utf8");
-      await handle.sync();
-      await handle.close();
-      handle = null;
-      if (!await lock.refresh()) {
-        throw new Error("CAS revision shard lock was lost.");
-      }
-      await rename2(temporaryPath, shardPath);
-    } finally {
-      if (handle !== null) {
-        await handle.close().catch((error) => {
-          log.warn("failed to close CAS revision shard temporary file", error);
-        });
-      }
-      await unlink2(temporaryPath).catch((error) => {
-        if (!isErrnoCode(error, "ENOENT")) {
-          log.warn("failed to clean up CAS revision shard temporary file", error);
-        }
-      });
-    }
-  }
-  async resolveRelativePath(filePath) {
-    const baseDir = path2.resolve(this.baseDir);
-    const target = await resolveSafeStoragePath(baseDir, path2.relative(baseDir, path2.resolve(baseDir, filePath)));
-    return path2.relative(baseDir, target).split(path2.sep).join("/");
-  }
-  async withShardLock(relativePath, task) {
-    const { lockPath } = await this.getSafeShardInfo(relativePath);
-    return await withHeldFileLock(
-      lockPath,
-      { staleMs: CAS_REVISION_LOCK_STALE_MS, maxWaitMs: CAS_REVISION_LOCK_MAX_WAIT_MS },
-      async (acquired, lock) => {
-        if (!acquired) throw new Error("CAS revision lock is unavailable.");
-        return await task(lock);
-      }
-    );
-  }
-  /** The target's standing revision token, or undefined when no receipt was
-   * ever minted for it. Fail-open on storage/read errors. */
-  async readRevision(filePath) {
-    try {
-      const relativePath = await this.resolveRelativePath(filePath);
-      return (await this.readStandingRevision(relativePath))?.revision;
-    } catch (error) {
-      log.warn(`CasRevisionStore.readRevision failed for ${filePath}: ${error}`);
-      return void 0;
-    }
-  }
-  /** #2813 (P1 A): the truthful standing-receipt read. `absent` means no
-   * receipt was ever minted for the target — undefined semantics stay
-   * correct for those records. `unavailable` means the sidecar could not
-   * be read OR a reservation is pending finalization; callers that
-   * transact on receipt identity MUST refuse rather than treat the
-   * failure as absence. */
-  async readRevisionStatus(filePath) {
-    try {
-      const relativePath = await this.resolveRelativePath(filePath);
-      const standing = await this.readStandingRevisionStrict(relativePath);
-      return standing === void 0 ? { status: "absent" } : {
-        status: "present",
-        revision: standing.revision,
-        ...standing.committedDigest !== void 0 ? { committedDigest: standing.committedDigest } : {},
-        ...standing.committedSemanticFingerprint !== void 0 ? { committedSemanticFingerprint: standing.committedSemanticFingerprint } : {}
-      };
-    } catch (error) {
-      return { status: "unavailable", reason: error instanceof Error ? error.message : String(error) };
-    }
-  }
-  /** #2813 (P1 C): reserve the NEXT revision token as a durable PENDING
-   * marker under the target's shard lock — the write-ahead record of a
-   * receipt transaction. The token is strictly greater than the standing
-   * token (max(clock, prev + 1ms)), so two commits can never share a
-   * receipt — not within one millisecond, not across a backward clock
-   * step. Refuses while another reservation is pending (recovery needed)
-   * or the standing receipt cannot be determined. The caller MUST either
-   * `commit` after its durable write lands or `abort` when it fails.
-   * #2807: the marker records the reserve-time fingerprint (`baselineDigest`)
-   * and optional expected post-write fingerprint (`expectedDigest`) with
-   * `writeLanded: false`. {@link recoverPendingRevision} decides crashes
-   * before or after the memory write from that evidence. */
-  async beginRevisionTransaction(filePath, expectedContent) {
-    const relativePath = await this.resolveRelativePath(filePath);
-    return await this.withShardLock(relativePath, async (lock) => {
-      const standingInfo = await this.readStandingRevisionStrict(relativePath);
-      const standing = standingInfo?.revision;
-      const next = nextCasRevisionIso(standing);
-      const baselineDigest = await this.digestDurableFile(relativePath);
-      const expectedDigest = expectedContent != null ? this.digestContent(expectedContent) : void 0;
-      const { shardPath } = await this.getSafeShardInfo(relativePath);
-      await this.writeShard(shardPath, relativePath, next, lock, "pending", standing, {
-        baselineDigest,
-        ...expectedDigest !== void 0 ? { expectedDigest } : {},
-        writeLanded: false
-      });
-      return {
-        pendingRevision: next,
-        writeLanded: () => this.recordPendingWriteLanded(relativePath, next),
-        commit: () => this.finalizeRevisionTransaction(relativePath, next, "commit"),
-        abort: () => this.finalizeRevisionTransaction(relativePath, next, "abort")
-      };
-    });
-  }
-  digestContent(content) {
-    const bytes = typeof content === "string" ? Buffer.from(content, "utf8") : content;
-    return createHash2("sha256").update(bytes).digest("hex");
-  }
-  async digestDurableFile(filePath) {
-    const bytes = await this.readDurableBytes(filePath);
-    return bytes === null ? null : createHash2("sha256").update(bytes).digest("hex");
-  }
-  /** #2870: canonical SEMANTIC fingerprint of the durable file — its text
-   * with the access-telemetry frontmatter keys stripped
-   * ({@link canonicalSemanticFileText}), hashed. Null means the file was
-   * absent. A fingerprint, never memory content. */
-  async semanticFingerprintDurableFile(filePath) {
-    const bytes = await this.readDurableBytes(filePath);
-    return bytes === null ? null : createHash2("sha256").update(canonicalSemanticFileText(bytes.toString("utf8"))).digest("hex");
-  }
-  async readDurableBytes(filePath) {
-    const relativePath = await this.resolveRelativePath(filePath);
-    const baseDir = path2.resolve(this.baseDir);
-    const target = await resolveSafeStoragePath(baseDir, relativePath);
-    try {
-      return await readFile2(target);
-    } catch (error) {
-      if (isErrnoCode(error, "ENOENT")) return null;
-      throw new Error(
-        `CAS revision evidence: durable memory file ${relativePath} is unreadable: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  /** #2807: mark the reserved write as landed. Verifies a pre-recorded
-   * expected digest against the durable file, or records the file digest
-   * when none was reserved. Sets `writeLanded: true`. Idempotent. */
-  async recordPendingWriteLanded(relativePath, token) {
-    await this.withShardLock(relativePath, async (lock) => {
-      const { shardPath } = await this.getSafeShardInfo(relativePath);
-      const view = await this.readShardView(shardPath, relativePath);
-      if (view.kind !== "pending" || view.foreign || view.revision !== token) {
-        throw new Error(
-          `CAS revision evidence recording refused for ${relativePath}: the pending marker does not match the reserved token.`
-        );
-      }
-      if (pendingWriteHasLanded(view) && view.writeLanded !== false) return;
-      const currentDigest = await this.digestDurableFile(relativePath);
-      if (view.expectedDigest !== void 0 && currentDigest !== view.expectedDigest) {
-        throw new Error(
-          `CAS revision evidence recording refused for ${relativePath}: the durable file does not match the reserved expected digest.`
-        );
-      }
-      await this.writeShard(shardPath, relativePath, token, lock, "pending", view.previous, {
-        baselineDigest: view.baselineDigest === void 0 ? null : view.baselineDigest,
-        expectedDigest: view.expectedDigest !== void 0 ? view.expectedDigest : currentDigest,
-        writeLanded: true
-      });
-    });
-  }
-  async finalizeRevisionTransaction(relativePath, token, outcome) {
-    await this.withShardLock(relativePath, async (lock) => {
-      const { shardPath } = await this.getSafeShardInfo(relativePath);
-      const view = await this.readShardView(shardPath, relativePath);
-      if (view.kind === "pending" && !view.foreign && view.revision === token) {
-        if (outcome === "commit") {
-          const committedDigest = view.expectedDigest ?? await this.digestDurableFile(relativePath);
-          const committedSemanticFingerprint = await this.semanticFingerprintDurableFile(relativePath);
-          await this.writeShard(shardPath, relativePath, token, lock, "committed", void 0, {
-            committedDigest,
-            committedSemanticFingerprint
-          });
-        } else if (view.previous !== void 0) {
-          await this.writeShard(shardPath, relativePath, view.previous, lock, "committed");
-        } else {
-          await unlink2(shardPath);
-        }
-        return;
-      }
-      if (outcome === "commit" && view.kind === "committed" && !view.foreign && view.revision === token) {
-        return;
-      }
-      if (outcome === "abort" && view.kind === "missing") {
-        return;
-      }
-      throw new Error(
-        `CAS revision transaction ${outcome} refused for ${relativePath}: the pending marker does not match the reserved token.`
-      );
-    });
-  }
-  /** #2837: remove the target's receipt shard once its durable memory file
-   * has been deleted, so orphan shards cannot accumulate. Under the shard
-   * lock: a PENDING marker is crash-recovery evidence for
-   * {@link recoverPendingRevision} and is KEPT ("pending"); a shard naming
-   * another target is KEPT ("foreign") — never destroy a receipt you cannot
-   * attribute. Never touches the durable memory file or the legacy global
-   * metadata: a stale legacy entry keeps per-path monotonicity if the path
-   * is ever reused. */
-  async removeRevisionShard(filePath) {
-    const relativePath = await this.resolveRelativePath(filePath);
-    return await this.withShardLock(relativePath, async () => {
-      const { shardPath } = await this.getSafeShardInfo(relativePath);
-      const view = await this.readShardView(shardPath, relativePath);
-      if (view.kind === "missing") return "absent";
-      if (view.kind === "pending") return view.foreign ? "foreign" : "pending";
-      if (view.kind === "foreign" || view.foreign) return "foreign";
-      await unlink2(shardPath);
-      return "removed";
-    });
-  }
-  /** #2813 (P1 C): recovery for a reservation left PENDING by a crash or a
-   * failed publication. The caller supplies the KNOWN outcome of the
-   * durable memory write: `fileWriteLanded` publishes the pending token as
-   * the COMMITTED receipt; otherwise the reservation is discarded and the
-   * previous standing token restored. Idempotent — an already-committed or
-   * absent shard is reported, not mutated. */
-  async reconcilePendingRevision(filePath, fileWriteLanded) {
-    const relativePath = await this.resolveRelativePath(filePath);
-    return await this.withShardLock(relativePath, async (lock) => {
-      const { shardPath } = await this.getSafeShardInfo(relativePath);
-      const view = await this.readShardView(shardPath, relativePath);
-      if (view.kind === "committed") return "committed";
-      if (view.kind !== "pending") return "absent";
-      if (view.foreign) {
-        throw new Error(
-          `CAS revision pending marker for ${relativePath} names another target; manual recovery is required.`
-        );
-      }
-      if (fileWriteLanded) {
-        const committedDigest = view.expectedDigest ?? await this.digestDurableFile(relativePath);
-        const committedSemanticFingerprint = await this.semanticFingerprintDurableFile(relativePath);
-        await this.writeShard(shardPath, relativePath, view.revision, lock, "committed", void 0, {
-          committedDigest,
-          committedSemanticFingerprint
-        });
-      } else if (view.previous !== void 0) {
-        await this.writeShard(shardPath, relativePath, view.previous, lock, "committed");
-      } else {
-        await unlink2(shardPath);
-      }
-      return "reconciled";
-    });
-  }
-  /** #2807 (P1): evidence-based recovery for a reservation left PENDING by
-   * a crash between reserve and finalize. Under the shard lock, the durable
-   * file's current fingerprint is compared against the marker:
-   * - matches `expectedDigest` → publish the pending token as COMMITTED;
-   * - matches `baselineDigest` (including both absent) → abort and restore;
-   * - anything else THROWS. Recovery never guesses.
-   *
-   * `onlyWithWriteEvidence` is the unlocked read path. A marker whose write
-   * has not landed (`writeLanded` false, or legacy with no expectedDigest)
-   * may belong to a live writer, so it returns `reserved`. A landed marker
-   * whose file no longer matches `expectedDigest` throws ambiguity. */
-  async recoverPendingRevision(filePath, options) {
-    const relativePath = await this.resolveRelativePath(filePath);
-    return await this.withShardLock(relativePath, async (lock) => {
-      const { shardPath } = await this.getSafeShardInfo(relativePath);
-      const view = await this.readShardView(shardPath, relativePath);
-      if (view.kind === "missing" || view.kind === "foreign") return "absent";
-      if (view.kind === "committed") return view.foreign ? "absent" : "committed";
-      if (view.foreign) {
-        throw new Error(
-          `CAS revision pending marker for ${relativePath} names another target; manual recovery is required.`
-        );
-      }
-      const currentDigest = await this.digestDurableFile(relativePath);
-      const landed = pendingWriteHasLanded(view);
-      if (options?.onlyWithWriteEvidence && !landed) {
-        return "reserved";
-      }
-      if (view.expectedDigest !== void 0 && currentDigest === view.expectedDigest) {
-        await this.writeShard(shardPath, relativePath, view.revision, lock, "committed", void 0, {
-          committedDigest: view.expectedDigest,
-          committedSemanticFingerprint: await this.semanticFingerprintDurableFile(relativePath)
-        });
-        return "committed";
-      }
-      if (options?.onlyWithWriteEvidence) {
-        const evidence2 = view.expectedDigest === void 0 ? "the pending marker carries no crash evidence (written by an older version)" : "the durable file matches neither the expected commit fingerprint nor the reserve-time baseline";
-        throw new Error(
-          `CAS revision recovery for ${relativePath} is ambiguous: ${evidence2} (pending token ${view.revision}${view.previous !== void 0 ? `, previous ${view.previous}` : ""}). Inspect the durable file and the shard at ${shardPath}, then run reconcilePendingRevision with the known write outcome. Refusing to guess.`
-        );
-      }
-      if (view.baselineDigest !== void 0 && currentDigest === view.baselineDigest) {
-        if (view.previous !== void 0) {
-          await this.writeShard(shardPath, relativePath, view.previous, lock, "committed");
-        } else {
-          await unlink2(shardPath);
-        }
-        return "aborted";
-      }
-      const evidence = view.baselineDigest === void 0 && view.expectedDigest === void 0 ? "the pending marker carries no crash evidence (written by an older version)" : "the durable file matches neither the expected commit fingerprint nor the reserve-time baseline";
-      throw new Error(
-        `CAS revision recovery for ${relativePath} is ambiguous: ${evidence} (pending token ${view.revision}${view.previous !== void 0 ? `, previous ${view.previous}` : ""}). Inspect the durable file and the shard at ${shardPath}, then run reconcilePendingRevision with the known write outcome. Refusing to guess.`
-      );
-    });
-  }
-};
-
-// src/storage/cas-revision-host.ts
-var CasRevisionHost = class extends CasRevisionStore {
-  /** Standing CAS revision token — receipt identity, never public `updated` (#2807). Fail-open on read errors. */
-  async readCasRevision(filePath) {
-    try {
-      return await this.readRevision(filePath);
-    } catch (err) {
-      log.warn(`storage.readCasRevision failed for ${filePath}: ${err}`);
-      return void 0;
-    }
-  }
-  /** #2813 (P1 A): truthful CAS receipt probe — distinguishes a genuinely
-   * ABSENT receipt (target predates the sidecar; `undefined` semantics stay
-   * correct) from an UNAVAILABLE one (unreadable shard: receipt identity is
-   * unknown). Transactional callers that must refuse on unknown identity
-   * route here; `readCasRevision` stays fail-open for advisory reads.
-   * #2807 (P1): a PENDING marker left by a crash is lazily recovered on
-   * this first read when its evidence is decisive; a reserve-only marker
-   * may belong to a live writer and defers to the path-locked write path,
-   * and ambiguity stays `unavailable` with an actionable reason. */
-  async readCasRevisionStatus(filePath) {
-    const status = await this.readRevisionStatus(filePath);
-    if (status.status !== "unavailable" || !/pending/i.test(status.reason)) return status;
-    try {
-      const outcome = await this.recoverPendingRevision(filePath, {
-        onlyWithWriteEvidence: true
-      });
-      if (outcome === "reserved") return status;
-    } catch (error) {
-      return {
-        status: "unavailable",
-        reason: error instanceof Error ? error.message : String(error)
-      };
-    }
-    return await this.readRevisionStatus(filePath);
-  }
-  async readDurableFileDigest(filePath) {
-    try {
-      return await this.digestDurableFile(filePath);
-    } catch (err) {
-      log.warn(`storage.readDurableFileDigest failed for ${filePath}: ${err}`);
-      return null;
-    }
-  }
-  /** #2807 (P1): reconcile any crash-orphaned PENDING marker for this
-   * target BEFORE the next semantic mutation reserves a new token —
-   * otherwise a crashed reservation would make the memory permanently
-   * unwritable. Decisive evidence heals; ambiguity throws so the
-   * mutation fails closed with the actionable recovery error. */
-  async beginRevision(pathname, expectedContent) {
-    await this.recoverPendingRevision(pathname);
-    return await this.beginRevisionTransaction(pathname, expectedContent);
-  }
-  /** #2837: best-effort post-deletion sweep of the target's receipt shard.
-   * The durable memory file is already gone, so a failed sweep must never
-   * fail the deletion itself — it logs instead. A PENDING shard (crash
-   * recovery evidence) and a foreign shard (another target's receipt) are
-   * kept, with a warning naming the recovery path. */
-  async sweepShardAfterDeletion(filePath) {
-    try {
-      const outcome = await this.removeRevisionShard(filePath);
-      if (outcome === "pending") {
-        log.warn(
-          `CAS revision shard for ${filePath} kept after memory deletion: a pending reservation stands \u2014 run recovery before the path is reused`
-        );
-      } else if (outcome === "foreign") {
-        log.warn(
-          `CAS revision shard for ${filePath} kept after memory deletion: the shard names another target`
-        );
-      }
-    } catch (err) {
-      log.warn(`failed to sweep CAS revision shard for deleted memory ${filePath}: ${err}`);
-    }
-  }
-};
-
-// src/storage/tombstone-blocked-capture-sync.ts
-import { createHash as createHash3, randomUUID as randomUUID4 } from "crypto";
-import { unlink as unlink4 } from "fs/promises";
-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 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);
-var REBUILD_RETRY_BASE_MS = 50;
-var ABANDONED_MARKER_MIN_AGE_MS = 6e4;
-var MARKER_PROCESS_START_TOLERANCE_MS = 2e3;
-var DOTNET_UNIX_EPOCH_TICKS = 621355968e9;
-var MARKER_PROCESS_STARTED_AT_MS = Date.now() - process.uptime() * 1e3;
-var TombstoneBlockedCaptureIndex = class {
-  options;
-  index = null;
-  loadPromise = null;
-  refreshPromise = null;
-  authoritative = false;
-  captureWriteLock;
-  constructor(options) {
-    this.options = options;
-    this.captureWriteLock = new TombstoneBlockedCaptureWriteLock({
-      stateDir: options.stateDir,
-      withHeldFileLock: options.withHeldFileLock,
-      lockOptions: options.captureLockLimitSource
-    });
-  }
-  createIndex() {
-    return new ContentHashIndex(
-      path3.join(this.options.stateDir, "tombstone-blocked-capture"),
-      this.options.secureStoreKeyProvider,
-      this.options.secureStoreWriteKeyProvider,
-      this.options.memoryDir,
-      this.options.lockOptions()
-    );
-  }
-  indexPath() {
-    return path3.join(this.options.stateDir, "tombstone-blocked-capture", "fact-hashes.txt");
-  }
-  rebuildMarkerPath() {
-    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 = path3.join(this.rebuildMarkerPath(), entry);
-          try {
-            const raw = (await readFile3(markerPath, "utf8")).trim();
-            if (raw === "committed") return { path: markerPath, committed: true };
-            let value;
-            let malformed = false;
-            try {
-              const parsed = JSON.parse(raw);
-              if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-                malformed = true;
-                value = {};
-              } else {
-                value = parsed;
-              }
-            } catch {
-              malformed = true;
-              value = {};
-            }
-            const state = value.state;
-            if (state !== "pending" && state !== "committed") malformed = true;
-            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);
-            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 {
-              path: markerPath,
-              committed: state === "committed",
-              ...typeof value.pid === "number" && Number.isInteger(value.pid) ? { pid: value.pid } : {},
-              ...ownerId.length > 0 ? { ownerId } : {},
-              ...typeof createdAt === "number" && Number.isFinite(createdAt) ? { createdAt } : {},
-              ...processStartedAtMs === void 0 ? {} : { processStartedAtMs },
-              ...malformed ? { malformed: true } : {}
-            };
-          } catch (err) {
-            if (isErrnoCode(err, "ENOENT")) return null;
-            throw err;
-          }
-        })
-      )).filter((marker) => marker !== null);
-    } catch (err) {
-      if (isErrnoCode(err, "ENOENT")) return [];
-      throw err;
-    }
-  }
-  async isAbandonedMarker(marker) {
-    if (marker.committed || marker.createdAt === void 0) return false;
-    if (Date.now() - marker.createdAt < ABANDONED_MARKER_MIN_AGE_MS) return false;
-    if (marker.malformed) return true;
-    return marker.pid !== void 0 && !await this.isProcessAlive(marker.pid, marker.processStartedAtMs);
-  }
-  async isProcessAlive(pid, processStartedAtMs) {
-    try {
-      process.kill(pid, 0);
-    } catch (err) {
-      return !isErrnoCode(err, "ESRCH");
-    }
-    if (processStartedAtMs === void 0) return true;
-    const runningStartedAtMs = await this.readProcessStartedAtMs(pid);
-    if (runningStartedAtMs === null) return true;
-    return runningStartedAtMs <= processStartedAtMs + MARKER_PROCESS_START_TOLERANCE_MS;
-  }
-  async readProcessStartedAtMs(pid) {
-    try {
-      if (process.platform === "win32") {
-        const { stdout: stdout2 } = await execFileAsync(
-          "powershell.exe",
-          [
-            "-NoLogo",
-            "-NoProfile",
-            "-NonInteractive",
-            "-Command",
-            `(Get-Process -Id ${pid} -ErrorAction Stop).StartTime.ToUniversalTime().Ticks`
-          ],
-          { encoding: "utf8", timeout: 1e3 }
-        );
-        const ticks = Number(stdout2.trim());
-        return Number.isFinite(ticks) ? (ticks - DOTNET_UNIX_EPOCH_TICKS) / 1e4 : null;
-      }
-      const { stdout } = await execFileAsync("ps", ["-p", String(pid), "-o", "lstart="], {
-        encoding: "utf8",
-        timeout: 1e3
-      });
-      const output = stdout.trim();
-      if (!output) return null;
-      const startedAtMs = Date.parse(output);
-      return Number.isFinite(startedAtMs) ? startedAtMs : null;
-    } catch {
-      return null;
-    }
-  }
-  async getClearableRebuildMarkerPaths(markers) {
-    const paths = await Promise.all(
-      markers.map(async (marker) => marker.committed || await this.isAbandonedMarker(marker) ? marker.path : null)
-    );
-    return paths.filter((markerPath) => markerPath !== null);
-  }
-  async getRebuildMarkers() {
-    return await this.readRebuildMarkers();
-  }
-  // A pending marker protects the pre-commit gap; only committed markers are safe for another writer to clear.
-  async writeMarkerAtomically(markerPath, payload) {
-    const temporaryPath = `${markerPath}.tmp-${process.pid}-${randomUUID3()}`;
-    try {
-      await writeFile(temporaryPath, payload, "utf8");
-      await rename3(temporaryPath, markerPath);
-    } finally {
-      await unlink3(temporaryPath).catch((err) => {
-        if (!isErrnoCode(err, "ENOENT")) throw err;
-      });
-    }
-  }
-  async markRebuildRequired(committed = false) {
-    const markerDir = this.rebuildMarkerPath();
-    await mkdir3(markerDir, { recursive: true });
-    const ownerId = randomUUID3();
-    const markerPath = path3.join(markerDir, ownerId);
-    await this.writeMarkerAtomically(
-      markerPath,
-      `${JSON.stringify({
-        state: committed ? "committed" : "pending",
-        pid: process.pid,
-        ownerId,
-        createdAt: Date.now(),
-        processStartedAtMs: MARKER_PROCESS_STARTED_AT_MS
-      })}
-`
-    );
-    return markerPath;
-  }
-  async markRebuildCommitted(markerPath) {
-    await this.writeMarkerAtomically(
-      markerPath,
-      `${JSON.stringify({
-        state: "committed",
-        pid: process.pid,
-        ownerId: path3.basename(markerPath),
-        createdAt: Date.now(),
-        processStartedAtMs: MARKER_PROCESS_STARTED_AT_MS
-      })}
-`
-    );
-  }
-  async clearRebuildRequired(markerPaths) {
-    await Promise.all(
-      markerPaths.map(async (markerPath) => {
-        try {
-          await unlink3(markerPath);
-        } catch (err) {
-          if (!isErrnoCode(err, "ENOENT")) throw err;
-        }
-      })
-    );
-  }
-  async hasRebuildRequired(excludedMarkers = []) {
-    const excluded = new Set(excludedMarkers);
-    return (await this.getRebuildMarkers()).some((marker) => !excluded.has(marker.path));
-  }
-  async setAuthoritative(rebuilt) {
-    this.authoritative = rebuilt && !(await this.getRebuildMarkers()).some((marker) => !marker.committed);
-  }
-  isBlocked(memory) {
-    return memory.frontmatter.status === "pending_review" && Boolean(memory.frontmatter.blockedBy);
-  }
-  async rebuild(index) {
-    return await index.rebuildUnderLock(async () => {
-      index.clear();
-      const existing = [...await this.options.readAllMemories(), ...await this.options.readAllColdMemories()];
-      for (const memory of existing) {
-        if (!this.isBlocked(memory)) continue;
-        index.add(
-          buildExplicitCaptureDedupKey(memory.content, memory.frontmatter.category, memory.frontmatter.sourceConnector)
-        );
-      }
-    });
-  }
-  async hasPersistedIndexOrMarkers() {
-    try {
-      await stat(this.indexPath());
-      return true;
-    } catch (err) {
-      if (!isErrnoCode(err, "ENOENT")) throw err;
-      return (await this.readRebuildMarkers()).length > 0;
-    }
-  }
-  async getIndex() {
-    if (this.index) return this.index;
-    if (!this.loadPromise) {
-      const index = this.createIndex();
-      this.loadPromise = (async () => {
-        await index.load();
-        const rebuildMarkers = await this.getRebuildMarkers();
-        const clearableRebuildMarkers = await this.getClearableRebuildMarkerPaths(rebuildMarkers);
-        let persisted = !index.requiresFormatMigration;
-        try {
-          await stat(this.indexPath());
-          if (rebuildMarkers.length > 0) persisted = false;
-        } catch (err) {
-          if (isErrnoCode(err, "ENOENT")) persisted = false;
-          else throw err;
-        }
-        if (!persisted) {
-          const lockOptions = this.options.lockOptions();
-          const maxAttempts = lockOptions.retryMaxAttempts ?? REBUILD_MAX_ATTEMPTS;
-          const baseMs = lockOptions.retryBaseMs ?? REBUILD_RETRY_BASE_MS;
-          let rebuilt = false;
-          for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-            rebuilt = await this.rebuild(index);
-            if (rebuilt || attempt === maxAttempts - 1) break;
-            const wait = Math.min(baseMs * 2 ** attempt, CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS);
-            const delayState = Promise.withResolvers();
-            setTimeout(delayState.resolve, wait);
-            await delayState.promise;
-          }
-          if (!rebuilt) {
-            throw new Error("tombstone-blocked capture index rebuild lock unavailable");
-          }
-          await this.clearRebuildRequired(clearableRebuildMarkers);
-        }
-        await this.setAuthoritative(true);
-        this.index = index;
-        return index;
-      })().catch((err) => {
-        this.loadPromise = null;
-        throw err;
-      });
-    }
-    return this.loadPromise;
-  }
-  async withCaptureWriteLock(task, identity) {
-    return await this.captureWriteLock.withCaptureWriteLock(task, identity);
-  }
-  async withCaptureWriteLockHashes(task, identityHashes) {
-    return await this.captureWriteLock.withCaptureWriteLockHashes(task, identityHashes);
-  }
-  async withCaptureWriteLockAndHashes(task, identity, identityHashes) {
-    return await this.captureWriteLock.withCaptureWriteLockAndHashes(task, identity, identityHashes);
-  }
-  async reload() {
-    if (!this.refreshPromise) {
-      this.refreshPromise = (async () => {
-        this.index = null;
-        this.loadPromise = null;
-        return await this.getIndex();
-      })().finally(() => {
-        this.refreshPromise = null;
-      });
-    }
-    return this.refreshPromise;
-  }
-  /** Return blocked-row membership and authority from one index snapshot. */
-  async check(content, category, sourceConnector) {
-    const key = buildExplicitCaptureDedupKey(content, category, sourceConnector);
-    let index = await this.getIndex();
-    if (await this.hasRebuildRequired() || !await index.isDiskFingerprintCurrent()) {
-      index = await this.reload();
-    }
-    return { has: index.has(key), authoritative: this.authoritative };
-  }
-  /** Return whether a blocked row matches this explicit-capture identity. */
-  async has(content, category, sourceConnector) {
-    return (await this.check(content, category, sourceConnector)).has;
-  }
-  /** Return whether the in-memory index is safe to answer an authoritative miss. */
-  async isAuthoritative() {
-    const index = await this.getIndex();
-    if (await this.hasRebuildRequired() || !await index.isDiskFingerprintCurrent()) {
-      await this.reload();
-    }
-    return this.authoritative;
-  }
-  /** Reserve durable rebuild intent before a blocked memory file is committed. */
-  async prepareWrite() {
-    return this.markRebuildRequired();
-  }
-  /** Mark a prepared write committed once its memory file is durable. */
-  async commitWrite(rebuildMarker) {
-    await this.markRebuildCommitted(rebuildMarker);
-  }
-  /** Drop a pending marker when the protected memory write never commits. */
-  async discardWrite(rebuildMarker) {
-    await this.clearRebuildRequired([rebuildMarker]);
-  }
-  /** Add a newly persisted blocked row to the durable targeted index. */
-  async add(memory, rebuildMarker) {
-    if (!this.isBlocked(memory)) return;
-    let index = await this.getIndex();
-    if (await this.hasRebuildRequired(rebuildMarker ? [rebuildMarker] : []) || !await index.isDiskFingerprintCurrent()) {
-      index = await this.reload();
-    }
-    index.add(
-      buildExplicitCaptureDedupKey(memory.content, memory.frontmatter.category, memory.frontmatter.sourceConnector)
-    );
-    const marker = rebuildMarker ?? await this.markRebuildRequired(true);
-    if (rebuildMarker) await this.markRebuildCommitted(rebuildMarker);
-    await index.saveMergingWithDisk();
-    await index.flushReconcileRetry();
-    if (index.hasPendingChanges) {
-      this.markUntrusted();
-      return;
-    }
-    await this.clearRebuildRequired([marker]);
-    await this.setAuthoritative(true);
-  }
-  /** Rebuild the index after a blocked row changes or is removed. */
-  async rebuildIfLoaded(ownedMarker) {
-    const index = this.index ?? (await this.hasPersistedIndexOrMarkers() ? this.getIndex() : null);
-    if (!index) return;
-    const rebuildMarkers = await this.getRebuildMarkers();
-    const rebuildMarker = await this.markRebuildRequired(true);
-    const clearableRebuildMarkers = await this.getClearableRebuildMarkerPaths(rebuildMarkers);
-    const rebuilt = await this.rebuild(await index);
-    if (rebuilt) {
-      await this.clearRebuildRequired([
-        ...clearableRebuildMarkers,
-        ...ownedMarker === void 0 || clearableRebuildMarkers.includes(ownedMarker) ? [] : [ownedMarker],
-        rebuildMarker
-      ]);
-    }
-    await this.setAuthoritative(rebuilt);
-  }
-  /** Rebuild when either side of a write is blocked and its identity changed. */
-  async sync(before, after, rebuildMarker) {
-    const beforeBlocked = this.isBlocked(before);
-    const afterBlocked = this.isBlocked(after);
-    if (!beforeBlocked && !afterBlocked) return;
-    const beforeKey = buildExplicitCaptureDedupKey(
-      before.content,
-      before.frontmatter.category,
-      before.frontmatter.sourceConnector
-    );
-    const afterKey = buildExplicitCaptureDedupKey(
-      after.content,
-      after.frontmatter.category,
-      after.frontmatter.sourceConnector
-    );
-    if (beforeBlocked && afterBlocked && beforeKey === afterKey) {
-      if (rebuildMarker) {
-        await this.markRebuildCommitted(rebuildMarker);
-        await this.clearRebuildRequired([rebuildMarker]);
-      }
-      return;
-    }
-    const existingMarkers = await this.getRebuildMarkers();
-    const marker = rebuildMarker ?? await this.markRebuildRequired(true);
-    const clearableExistingMarkers = await this.getClearableRebuildMarkerPaths(existingMarkers);
-    if (rebuildMarker) await this.markRebuildCommitted(rebuildMarker);
-    const rebuilt = await this.rebuild(await this.getIndex());
-    if (rebuilt) {
-      await this.clearRebuildRequired([...clearableExistingMarkers, marker]);
-    }
-    await this.setAuthoritative(rebuilt);
-  }
-  markUntrusted() {
-    this.authoritative = false;
-  }
-  async failOpen(operation, action) {
-    try {
-      await action();
-    } catch (err) {
-      this.markUntrusted();
-      log.warn(`storage.${operation} completed but failed to update tombstone-blocked capture index: ${err}`);
-    }
-  }
-  async addWrittenMemory(pathname, frontmatter, content, rebuildMarker) {
-    await this.failOpen("writeMemory", () => this.add({ path: pathname, frontmatter, content }, rebuildMarker));
-  }
-  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));
-  }
-  async syncUpdatedFrontmatter(before, frontmatter, rebuildMarker) {
-    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];
-    return category === "cold" || RECALL_FALLBACK_DIRS.includes(category);
-  }
-};
-
-// src/storage/tombstone-blocked-capture-sync.ts
-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");
-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) {
-      sink.write(output);
-      output = "";
-    }
-  };
-  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;
-        }
-        resolveSigma(cased);
-      }
-      if (character === "\u03A3" && precededByCased) {
-        flush();
-        sink.beginConditionalSigma();
-        pendingSigma = true;
-        precededByCased = true;
-        continue;
-      }
-      emit(character.toLowerCase());
-      if (!caseIgnorable) precededByCased = cased;
-    }
-  };
-  return {
-    push,
-    finish() {
-      if (pendingSigma) resolveSigma(false);
-      flush();
-    }
-  };
-}
-async function forEachStagedTextChunk(stagePath, offset, onText, key, memoryDir) {
-  const decoder = new TextDecoder("utf-8");
-  let remaining = offset;
-  for await (const chunk of readMaybeEncryptedFileFromChunks(stagePath, key, memoryDir)) {
-    const textChunk = remaining >= chunk.length ? null : chunk.subarray(remaining);
-    remaining = Math.max(0, remaining - chunk.length);
-    if (textChunk === null || textChunk.length === 0) continue;
-    const text = decoder.decode(textChunk, { stream: true });
-    if (text.length > 0) onText(text);
-  }
-  const finalText = decoder.decode();
-  if (finalText.length > 0) onText(finalText);
-}
-async function findStagedBodyOffset(stagePath, key, memoryDir) {
-  let scannedBytes = 0;
-  let tail = Buffer.alloc(0);
-  for await (const chunk of readMaybeEncryptedFileFromChunks(stagePath, key, memoryDir)) {
-    const window = tail.length > 0 ? Buffer.concat([tail, chunk]) : chunk;
-    const windowStart = scannedBytes - tail.length;
-    for (let searchFrom = 0; ; ) {
-      const delimiterStart = window.indexOf(OFFLINE_SYNC_FRONTMATTER_DELIMITER, searchFrom);
-      if (delimiterStart < 0) break;
-      if (windowStart + delimiterStart >= 4) {
-        return windowStart + delimiterStart + OFFLINE_SYNC_FRONTMATTER_DELIMITER.length;
-      }
-      searchFrom = delimiterStart + 1;
-    }
-    scannedBytes += chunk.length;
-    const tailLength = Math.min(OFFLINE_SYNC_FRONTMATTER_DELIMITER.length - 1, window.length);
-    tail = Buffer.from(window.subarray(window.length - tailLength));
-  }
-  return null;
-}
-async function readStagedPrefix(stagePath, byteLimit, key, memoryDir) {
-  const chunks = [];
-  let bytesRead = 0;
-  for await (const chunk of readMaybeEncryptedFileFromChunks(stagePath, key, memoryDir)) {
-    const length = Math.min(chunk.length, byteLimit - bytesRead);
-    if (length > 0) chunks.push(chunk.subarray(0, length));
-    bytesRead += length;
-    if (bytesRead >= byteLimit) break;
-  }
-  return Buffer.concat(chunks, bytesRead);
-}
-function parseTombstoneBlockedOfflineSyncMemory(filePath, content, memoryDir, parseFrontmatter, normalizeFrontmatterForPath, toMemoryPathRel) {
-  const parsed = parseFrontmatter(content.toString("utf8"));
-  if (!parsed) return null;
-  return {
-    path: filePath,
-    frontmatter: normalizeFrontmatterForPath(parsed.frontmatter, toMemoryPathRel(memoryDir, filePath), parsed.content),
-    content: parsed.content
-  };
-}
-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;
-  }
-  /** #2837 (shard cleanup): after a managed memory file is durably deleted,
-   * sweep its per-target CAS receipt shard so orphan shards cannot grow
-   * forever. The sweep runs under the shard's own lock and is best-effort —
-   * the memory file is already gone, so a sweep failure logs and never
-   * fails the delete. The sweeper is a second CasRevisionHost over the same
-   * memory dir; the host is stateless and every mutation serializes through
-   * the sidecar's file locks, so it shares the same shard files
-   * StorageManager's own host operates on. */
-  deletedMemoryShardSweeper = null;
-  async deleteManagedStorageFile(filePath, deletionMtimeMs) {
-    const deleted = await this.deleteManagedStorageFileDurable(filePath, deletionMtimeMs);
-    if (!deleted) return false;
-    if (this.deletedMemoryShardSweeper === null) {
-      this.deletedMemoryShardSweeper = new CasRevisionHost(this.tombstoneBlockedCaptureIndexOptions().memoryDir);
-    }
-    await this.deletedMemoryShardSweeper.sweepShardAfterDeletion(filePath);
-    return true;
-  }
-  async writeStorageSecureFileChunks(filePath, chunks) {
-    const options = this.tombstoneBlockedCaptureIndexOptions();
-    await writeMaybeEncryptedFileFromChunks(
-      filePath,
-      chunks,
-      options.secureStoreWriteKeyProvider(),
-      {},
-      options.memoryDir
-    );
-    this.notifyCatalogWriteForPath(filePath);
-  }
-  getTombstoneBlockedCaptureIndex() {
-    if (this.tombstoneBlockedCaptureIndex === null) {
-      this.tombstoneBlockedCaptureIndex = new TombstoneBlockedCaptureIndex(this.tombstoneBlockedCaptureIndexOptions());
-    }
-    return this.tombstoneBlockedCaptureIndex;
-  }
-  async withTombstoneBlockedCaptureWriteLock(task, identity) {
-    return await this.getTombstoneBlockedCaptureIndex().withCaptureWriteLock(task, identity);
-  }
-  /** Read selected memories while their mutation locks remain held. */
-  async readMemorySnapshotsIfUnchanged(expected) {
-    return await this.withMemorySnapshotsIfUnchanged(expected, async (memories) => memories);
-  }
-  async withMemorySnapshotsIfUnchanged(expected, task) {
-    if (expected.length === 0) return await task([]);
-    const pathnames = [...new Set(expected.map((memory) => memory.path))];
-    if (pathnames.length !== expected.length) return null;
-    return await this.withTombstoneBlockedCaptureWriteLock(async () => {
-      const current = await Promise.all(pathnames.map((pathname) => this.readMemoryByPath(pathname)));
-      for (let index = 0; index < expected.length; index += 1) {
-        const actual = current[index];
-        const snapshot = expected[index];
-        if (!actual || !snapshot || actual.frontmatter.id !== snapshot.frontmatter.id || invalidationCommitFingerprint(actual) !== invalidationCommitFingerprint(snapshot)) {
-          return null;
-        }
-      }
-      return await task(current);
-    }, pathnames.map(buildCapturePathLockIdentity));
-  }
-  async withTombstoneBlockedCaptureWriteLockAndHashes(task, identity, identityHashes) {
-    return await this.getTombstoneBlockedCaptureIndex().withCaptureWriteLockAndHashes(task, identity, identityHashes);
-  }
-  async writeTombstoneBlockedMutation(blocked, pathname, fileContent, identity, updateIndex, beforeIndexUpdate, coordinate = false, shouldMintRevision) {
-    const host = {
-      readCurrent: () => this.readMemoryByPath(pathname),
-      isBlocked: (memory) => this.isTombstoneBlockedMemory(memory),
-      isQueuedReview: (memory) => isQueuedReviewMemory(memory),
-      memoryIdentity: (memory) => this.offlineSyncMemoryIdentity(memory),
-      prepareWrite: () => this.getTombstoneBlockedCaptureIndex().prepareWrite(),
-      commitWrite: (marker) => this.getTombstoneBlockedCaptureIndex().commitWrite(marker),
-      discardWrite: (marker) => this.getTombstoneBlockedCaptureIndex().discardWrite(marker),
-      markUntrusted: () => this.getTombstoneBlockedCaptureIndex().markUntrusted(),
-      writeStorageSecureFile: (target, content) => this.writeStorageSecureFile(target, content),
-      withCaptureWriteLock: (task, lockIdentity) => this.withTombstoneBlockedCaptureWriteLock(task, lockIdentity),
-      logWarning: (message) => log.warn(message),
-      beginDurableMemoryRevision: (targetPath, expectedContent) => this.beginDurableMemoryRevision(targetPath, expectedContent)
-    };
-    return await runTombstoneBlockedMutation(host, {
-      blocked,
-      pathname,
-      fileContent,
-      identity,
-      updateIndex,
-      beforeIndexUpdate,
-      coordinate,
-      shouldMintRevision
-    });
-  }
-  async writeTombstoneBlockedMemory(pathname, fileContent, frontmatter, content, beforeIndexUpdate) {
-    await this.writeTombstoneBlockedMutation(
-      tombstoneBlocked(frontmatter),
-      pathname,
-      fileContent,
-      [
-        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) {
-    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) {
-    return await this.writeTombstoneBlockedMutation(
-      tombstoneBlocked(before.frontmatter) || tombstoneBlocked(frontmatter),
-      before.path,
-      fileContent,
-      [
-        buildCapturePathLockIdentity(before.path),
-        this.offlineSyncMemoryIdentity(before),
-        buildExplicitCaptureDedupKey(content, frontmatter.category, frontmatter.sourceConnector)
-      ],
-      (rebuildMarker, current) => this.getTombstoneBlockedCaptureIndex().syncUpdatedMemory(
-        current ?? before,
-        frontmatter,
-        content,
-        rebuildMarker
-      ),
-      beforeIndexUpdate,
-      true,
-      () => true
-    );
-  }
-  async writeTombstoneBlockedFrontmatter(before, fileContent, frontmatter, beforeIndexUpdate) {
-    return await this.writeTombstoneBlockedMutation(
-      tombstoneBlocked(before.frontmatter) || tombstoneBlocked(frontmatter),
-      before.path,
-      fileContent,
-      [
-        buildCapturePathLockIdentity(before.path),
-        this.offlineSyncMemoryIdentity(before),
-        buildExplicitCaptureDedupKey(before.content, frontmatter.category, frontmatter.sourceConnector)
-      ],
-      (rebuildMarker, current) => this.getTombstoneBlockedCaptureIndex().syncUpdatedFrontmatter(current ?? before, frontmatter, rebuildMarker),
-      beforeIndexUpdate,
-      true,
-      (current) => isSemanticFrontmatterChange((current ?? before).frontmatter, frontmatter)
-    );
-  }
-  isTombstoneBlockedMemory(memory) {
-    return memory !== null && memory.frontmatter.status === "pending_review" && Boolean(memory.frontmatter.blockedBy);
-  }
-  offlineSyncMemoryIdentity(memory) {
-    return buildExplicitCaptureDedupKey(
-      memory.content,
-      memory.frontmatter.category,
-      memory.frontmatter.sourceConnector
-    );
-  }
-  async isDuplicateTombstoneBlockedOfflineSync(target, incoming, streamedIdentity) {
-    const before = await this.readMemoryByPath(target);
-    const duplicate = streamedIdentity ? true : await this.getTombstoneBlockedCaptureIndex().has(
-      incoming.content,
-      incoming.frontmatter.category,
-      incoming.frontmatter.sourceConnector
-    );
-    if (!duplicate) return false;
-    const incomingIdentity = streamedIdentity?.identityHash ?? this.offlineSyncMemoryIdentity(incoming);
-    const options = this.tombstoneBlockedCaptureIndexOptions();
-    const existing = [...await options.readAllMemories(), ...await options.readAllColdMemories()];
-    const exactMatch = existing.some(
-      (memory) => this.isTombstoneBlockedMemory(memory) && (streamedIdentity ? captureIdentityHash(memory) : this.offlineSyncMemoryIdentity(memory)) === incomingIdentity
-    );
-    if (!exactMatch) return false;
-    if (before === null) return true;
-    if (!this.isTombstoneBlockedMemory(before)) return false;
-    const beforeIdentity = streamedIdentity ? captureIdentityHash(before) : this.offlineSyncMemoryIdentity(before);
-    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, blockedKeySetMayHaveChanged = true) {
-    this.invalidateAllMemoriesCache();
-    this.invalidateKnowledgeIndexCache();
-    this.markFactHashIndexNotAuthoritative();
-    if (filePath.includes(`${path4.sep}cold${path4.sep}`)) {
-      this.invalidateColdMemoriesCache();
-    }
-    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();
-    }
-    const memoryDir = this.tombstoneBlockedCaptureIndexOptions().memoryDir;
-    bumpArchiveMutationForPath(memoryDir, archiveChanged, filePath);
-    this.bumpMemoryStatusVersion();
-  }
-  async runTombstoneBlockedArchive(memory, task) {
-    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();
-        }
-      }
-      return archivedPath !== null;
-    });
-    return archived ? archivedPath : null;
-  }
-  async runTombstoneBlockedInvalidation(memory, task, propagateErrors = false, coordinate = false) {
-    let lockIdentities = [
-      buildCapturePathLockIdentity(memory.path),
-      ...coordinate || this.isTombstoneBlockedMemory(memory) || isQueuedReviewMemory(memory) ? [this.offlineSyncMemoryIdentity(memory)] : []
-    ];
-    for (; ; ) {
-      const attempt = async () => {
-        const options = this.tombstoneBlockedCaptureIndexOptions();
-        const current = await this.readMemoryByPath(memory.path) ?? (await options.readAllMemories()).find((candidate) => candidate.frontmatter.id === memory.frontmatter.id) ?? (await options.readAllColdMemories()).find((candidate) => candidate.frontmatter.id === memory.frontmatter.id);
-        if (!current) return { result: false };
-        const blocked = this.isTombstoneBlockedMemory(current);
-        const queuedReview = isQueuedReviewMemory(current);
-        if (blocked || queuedReview) {
-          const currentIdentity = this.offlineSyncMemoryIdentity(current);
-          if (!lockIdentities.includes(currentIdentity)) return { retryIdentity: currentIdentity };
-        }
-        const blockedIndex = blocked ? this.getTombstoneBlockedCaptureIndex() : null;
-        let rebuildMarker;
-        let durable = false;
-        try {
-          if (blockedIndex) rebuildMarker = await blockedIndex.prepareWrite();
-          const result2 = await task(current, rebuildMarker, () => {
-            durable = true;
-          });
-          if (!result2 && rebuildMarker && !durable && blockedIndex) {
-            try {
-              await blockedIndex.discardWrite(rebuildMarker);
-            } catch {
-              blockedIndex.markUntrusted();
-            }
-          }
-          return { result: result2 };
-        } catch (error) {
-          if (rebuildMarker && !durable && blockedIndex) {
-            try {
-              await blockedIndex.discardWrite(rebuildMarker);
-            } catch {
-              blockedIndex.markUntrusted();
-            }
-          }
-          if (propagateErrors) throw error;
-          return { result: false };
-        }
-      };
-      const result = await this.withTombstoneBlockedCaptureWriteLock(attempt, lockIdentities);
-      if (result.retryIdentity !== void 0) {
-        lockIdentities = [.../* @__PURE__ */ new Set([...lockIdentities, result.retryIdentity])];
-        continue;
-      }
-      return result.result;
-    }
-  }
-  async deleteMemoryForMaintenance(memory, shouldDelete = () => true) {
-    let deleted = null;
-    const removed = await this.runTombstoneBlockedInvalidation(
-      memory,
-      async (current, rebuildMarker, markDurable) => {
-        if (!shouldDelete(current)) return false;
-        if (!await this.deleteManagedStorageFile(current.path)) return false;
-        markDurable();
-        deleted = current;
-        const memoryDir = this.tombstoneBlockedCaptureIndexOptions().memoryDir;
-        bumpArchiveMutationForPath(memoryDir, true, current.path);
-        markProjectedMemoryPathInvalid(memoryDir, current.frontmatter.id);
-        this.invalidateAllMemoriesCache();
-        if (current.path.includes(`${path4.sep}cold${path4.sep}`)) {
-          this.invalidateColdMemoriesCache();
-        }
-        await this.rebuildTombstoneBlockedCaptureAfterInvalidation(rebuildMarker);
-        this.bumpMemoryCorpusVersion();
-        this.bumpMemoryStatusVersion();
-        return true;
-      },
-      true,
-      true
-    );
-    return removed ? deleted : null;
-  }
-  async runTombstoneBlockedOfflineSyncMutation(target, after, write, coordinate = false, streamedIdentity) {
-    for (; ; ) {
-      const before = await this.readMemoryByPath(target);
-      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],
-        ...afterIdentity === void 0 ? [] : [afterIdentity]
-      ];
-      let retryIdentity;
-      const mutate = async () => {
-        const current = await this.readMemoryByPath(target);
-        if (current !== null) {
-          const currentIdentity = this.offlineSyncMemoryIdentity(current);
-          if (currentIdentity !== targetIdentity) {
-            retryIdentity = currentIdentity;
-            return;
-          }
-        }
-        if (this.isTombstoneBlockedMemory(after) && await this.isDuplicateTombstoneBlockedOfflineSync(target, after, streamedIdentity)) {
-          return;
-        }
-        const affectsBlockedIndex = coordinate || this.isTombstoneBlockedMemory(current) || this.isTombstoneBlockedMemory(after);
-        const marker = affectsBlockedIndex ? await this.getTombstoneBlockedCaptureIndex().prepareWrite() : void 0;
-        let durable = false;
-        try {
-          const changed = await write();
-          durable = true;
-          if (marker) {
-            try {
-              await this.getTombstoneBlockedCaptureIndex().commitWrite(marker);
-            } catch (err) {
-              this.getTombstoneBlockedCaptureIndex().markUntrusted();
-              log.warn(`storage.offlineSyncFile committed write marker failed: ${err}`);
-            }
-          }
-          await this.invalidateAfterOfflineSyncMutation(
-            target,
-            marker,
-            changed !== false,
-            this.isTombstoneBlockedMemory(current) || this.isTombstoneBlockedMemory(after)
-          );
-        } catch (err) {
-          if (marker && !durable) {
-            try {
-              await this.getTombstoneBlockedCaptureIndex().discardWrite(marker);
-            } catch (cleanupError) {
-              this.getTombstoneBlockedCaptureIndex().markUntrusted();
-              log.warn(`storage.offlineSyncFile failed to clear write marker: ${cleanupError}`);
-            }
-          }
-          throw err;
-        }
-      };
-      if (!mustCoordinate) {
-        await mutate();
-      } else if (streamedIdentity) {
-        await this.withTombstoneBlockedCaptureWriteLockAndHashes(mutate, identities, [streamedIdentity.identityHash]);
-      } else {
-        await this.withTombstoneBlockedCaptureWriteLock(mutate, identities);
-      }
-      if (retryIdentity !== void 0) continue;
-      return;
-    }
-  }
-  async writeTombstoneBlockedOfflineSyncFile(target, content) {
-    const options = this.tombstoneBlockedCaptureIndexOptions();
-    const after = options.parseMemory?.(target, content) ?? null;
-    await withRawEntityPageMutation(path4.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;
-    if (!parseMemory) return { after: null, chunks };
-    const iterator = chunks[Symbol.asyncIterator]();
-    const buffered = [];
-    let bufferedBytes = 0;
-    let firstOverflow;
-    for (; ; ) {
-      const next = await iterator.next();
-      if (next.done) break;
-      if (bufferedBytes + next.value.length > OFFLINE_SYNC_BUFFER_LIMIT_BYTES) {
-        firstOverflow = next.value;
-        break;
-      }
-      bufferedBytes += next.value.length;
-      buffered.push(next.value);
-    }
-    const overflow = firstOverflow;
-    if (overflow === void 0) {
-      let after = null;
-      try {
-        after = parseMemory(target, Buffer.concat(buffered));
-      } catch {
-        after = null;
-      }
-      const replay = (async function* () {
-        for (const chunk of buffered) yield chunk;
-      })();
-      return { after, chunks: replay };
-    }
-    const options = this.tombstoneBlockedCaptureIndexOptions();
-    const stagePath = path4.join(
-      options.stateDir,
-      "tombstone-blocked-capture",
-      "offline-sync-staging",
-      `${randomUUID4()}.stage`
-    );
-    const stagedChunks = (async function* () {
-      for (const chunk of buffered) yield chunk;
-      yield overflow;
-      for (; ; ) {
-        const next = await iterator.next();
-        if (next.done) break;
-        yield next.value;
-      }
-    })();
-    try {
-      await writeMaybeEncryptedFileFromChunks(
-        stagePath,
-        stagedChunks,
-        options.secureStoreWriteKeyProvider(),
-        { atomic: false },
-        options.memoryDir
-      );
-      return await this.describeStagedOfflineSyncChunks(target, stagePath, parseMemory);
-    } catch (err) {
-      await unlink4(stagePath).catch(() => {
-      });
-      throw err;
-    }
-  }
-  async describeStagedOfflineSyncChunks(target, stagePath, parseMemory) {
-    const options = this.tombstoneBlockedCaptureIndexOptions();
-    const key = options.secureStoreKeyProvider();
-    const bodyOffset = await findStagedBodyOffset(stagePath, key, options.memoryDir);
-    if (bodyOffset === null) {
-      return { after: null, chunks: this.readStagedOfflineSyncChunks(stagePath), stagePath };
-    }
-    const prefix = await readStagedPrefix(stagePath, bodyOffset, key, options.memoryDir);
-    let after = null;
-    try {
-      after = parseMemory(target, prefix.subarray(0, bodyOffset));
-    } catch {
-      after = null;
-    }
-    if (after === null) {
-      return { after: null, chunks: this.readStagedOfflineSyncChunks(stagePath), stagePath };
-    }
-    const streamedIdentity = await this.computeStagedOfflineSyncIdentity(stagePath, bodyOffset, after);
-    return {
-      after,
-      chunks: this.readStagedOfflineSyncChunks(stagePath),
-      stagePath,
-      streamedIdentity
-    };
-  }
-  async computeStagedOfflineSyncIdentity(stagePath, bodyOffset, after) {
-    let normalizedLength = 0;
-    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);
-    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(" ");
-    let identityHash = createHash3("sha256");
-    let normalSigmaIdentityHash;
-    identityHash.update(identityPrefix);
-    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,
-      (text) => identityNormalizer.push(text),
-      key,
-      options.memoryDir
-    );
-    identityNormalizer.finish();
-    return {
-      identityHash: identityHash.digest("hex")
-    };
-  }
-  async *readStagedOfflineSyncChunks(stagePath) {
-    const options = this.tombstoneBlockedCaptureIndexOptions();
-    for await (const chunk of readMaybeEncryptedFileFromChunks(
-      stagePath,
-      options.secureStoreKeyProvider(),
-      options.memoryDir
-    )) {
-      yield chunk;
-    }
-  }
-  async writeTombstoneBlockedOfflineSyncFileChunks(target, chunks) {
-    const coordinate = this.getTombstoneBlockedCaptureIndex().shouldRebuildAfterInvalidationForPath(target);
-    const prepared = coordinate ? await this.prepareTombstoneBlockedOfflineSyncChunks(target, chunks) : { after: null, chunks };
-    const streamedIdentity = prepared.streamedIdentity;
-    const baseDir = path4.dirname(this.tombstoneBlockedCaptureIndexOptions().stateDir);
-    try {
-      await withRawEntityPageMutation(baseDir, target, async () => {
-        await this.runTombstoneBlockedOfflineSyncMutation(
-          target,
-          prepared.after,
-          () => this.writeManagedStorageFile(target, () => this.writeStorageSecureFileChunks(target, prepared.chunks)),
-          coordinate,
-          streamedIdentity
-        );
-      });
-    } finally {
-      if (prepared.stagePath !== void 0) await unlink4(prepared.stagePath).catch(() => {
-      });
-    }
-  }
-  async writeOfflineSyncFile(filePath, content) {
-    const target = this.assertManagedStoragePath(filePath, "storage.writeOfflineSyncFile");
-    await this.writeTombstoneBlockedOfflineSyncFile(target, content);
-    await this.requestSyncReconcileIfMigrationPath(target);
-  }
-  async writeOfflineSyncFileChunks(filePath, chunks) {
-    const target = this.assertManagedStoragePath(filePath, "storage.writeOfflineSyncFileChunks");
-    await this.writeTombstoneBlockedOfflineSyncFileChunks(target, chunks);
-    await this.requestSyncReconcileIfMigrationPath(target);
-  }
-  /**
-   * Opaque replicated bytes can restore legacy memory references or entity
-   * relationship targets. Other sync traffic must not request reconciliation.
-   */
-  async requestSyncReconcileIfMigrationPath(target) {
-    const stateDir = this.tombstoneBlockedCaptureIndexOptions().stateDir;
-    if (!pathMayCarryEntityRefs(path4.dirname(stateDir), target)) return;
-    await requestEntityCanonicalIdReconcile(stateDir);
-  }
-  async deleteOfflineSyncFile(filePath, deletionMtimeMs) {
-    const target = this.assertManagedStoragePath(filePath, "storage.deleteOfflineSyncFile");
-    await this.deleteTombstoneBlockedOfflineSyncFile(target, deletionMtimeMs);
-    await this.requestSyncReconcileIfMigrationPath(target);
-  }
-  async deleteTombstoneBlockedOfflineSyncFile(target, deletionMtimeMs) {
-    const stateDir = this.tombstoneBlockedCaptureIndexOptions().stateDir;
-    await withRawEntityPageMutation(path4.dirname(stateDir), target, async () => {
-      await this.runTombstoneBlockedOfflineSyncMutation(target, null, async () => {
-        return await this.deleteManagedStorageFile(target, deletionMtimeMs);
-      });
-    });
-  }
-  async checkTombstoneBlockedExplicitCapture(...args) {
-    return this.getTombstoneBlockedCaptureIndex().check(...args);
-  }
-  async hasTombstoneBlockedExplicitCapture(...args) {
-    return this.getTombstoneBlockedCaptureIndex().has(...args);
-  }
-  async isTombstoneBlockedExplicitCaptureIndexAuthoritative() {
-    return this.getTombstoneBlockedCaptureIndex().isAuthoritative();
-  }
-  async rebuildTombstoneBlockedCaptureAfterInvalidationForPath(filePath, ownedMarker) {
-    const index = this.getTombstoneBlockedCaptureIndex();
-    if (index.shouldRebuildAfterInvalidationForPath(filePath)) {
-      await this.rebuildTombstoneBlockedCaptureAfterInvalidation(ownedMarker);
-    }
-  }
-  async rebuildTombstoneBlockedCaptureAfterInvalidation(ownedMarker) {
-    await this.getTombstoneBlockedCaptureIndex().rebuildAfterInvalidation(ownedMarker);
-  }
-};
-
-export {
-  invalidationCommitFingerprint,
-  casCommittedRevisionOf,
-  withCasCommitReceipt,
-  DeletionRevisionStore,
-  canonicalSemanticFileText,
-  CasRevisionHost,
-  parseTombstoneBlockedOfflineSyncMemory,
-  TombstoneBlockedCaptureIndexHost
-};
-//# sourceMappingURL=chunk-FHGWKODN.js.map