@ricsam/r5d-worker 0.0.131 → 0.0.133

package/dist/mjs/workspace-hydration-ledger.mjs

@@ -0,0 +1,42 @@
+class WorkspaceHydrationPreBlobLedger {
+  mounts = /* @__PURE__ */ new Map();
+  static key(mount) {
+    return `${mount.hydrationIncarnationKey}\0${mount.id}`;
+  }
+  /** Blob ids by mount-relative path for the mount, or an empty map. */
+  preBlobs(mount) {
+    return this.mounts.get(WorkspaceHydrationPreBlobLedger.key(mount)) ?? /* @__PURE__ */ new Map();
+  }
+  /** Record the pre-hydration blob of every path a merge hydration replaced; earlier entries for other paths are kept. */
+  record(mount, preBlobs) {
+    const entries = preBlobs instanceof Map ? [...preBlobs] : Object.entries(preBlobs);
+    if (entries.length === 0) return;
+    const key = WorkspaceHydrationPreBlobLedger.key(mount);
+    const current = this.mounts.get(key) ?? /* @__PURE__ */ new Map();
+    for (const [relativePath, blob] of entries) current.set(relativePath, blob);
+    this.mounts.set(key, current);
+  }
+  /** Forget the mount: its checkout was rewritten by something this ledger did not observe. */
+  clearMount(mount) {
+    this.mounts.delete(WorkspaceHydrationPreBlobLedger.key(mount));
+  }
+  /** Forget paths whose checkout content moved on from the hydrated bytes: a later return to the old bytes is a deliberate edit. */
+  forget(mount, paths) {
+    const key = WorkspaceHydrationPreBlobLedger.key(mount);
+    const current = this.mounts.get(key);
+    if (!current) return;
+    for (const relativePath of paths) current.delete(relativePath);
+    if (current.size === 0) this.mounts.delete(key);
+  }
+  clear() {
+    this.mounts.clear();
+  }
+  get size() {
+    let total = 0;
+    for (const entries of this.mounts.values()) total += entries.size;
+    return total;
+  }
+}
+export {
+  WorkspaceHydrationPreBlobLedger
+};

package/dist/mjs/workspace-hydration-merge.mjs

@@ -0,0 +1,399 @@
+import fs from "node:fs";
+import path from "node:path";
+import { workerGitProcessEnvironment } from "./git-process-environment.mjs";
+import { gitBlobHash, gitObjectHashAlgorithmFor } from "./git-blob-hash.mjs";
+import { isBinaryContent, mergeThreeWay } from "./three-way-merge.mjs";
+import {
+  inspectWorkingTreePath,
+  projectedFileEntryMatches,
+  workingTreeStatsMatch
+} from "./working-tree-mirror.mjs";
+const RACY_PROJECTION_WINDOW_MS = 2e3;
+class TargetChanged extends Error {
+  constructor(relativePath) {
+    super(`Working-tree target changed while merge hydration inspected it: ${relativePath}`);
+    this.relativePath = relativePath;
+  }
+  relativePath;
+}
+function isBlobMode(mode) {
+  return mode === "100644" || mode === "100755";
+}
+function executableBit(mode) {
+  return (mode & 73) !== 0;
+}
+function resolveExecutable(base, ours, theirs) {
+  if (ours === base) return theirs;
+  if (theirs === base) return ours;
+  return ours === theirs ? ours : null;
+}
+function withExecutable(mode, executable) {
+  const bits = mode & 511;
+  return executable ? bits | 73 : bits & ~73;
+}
+function readOwnedFile(root, relativePath, expected) {
+  const inspected = inspectWorkingTreePath(root, relativePath);
+  if (inspected.kind !== "entry" || !workingTreeStatsMatch(expected, inspected.stat)) throw new TargetChanged(relativePath);
+  const descriptor = fs.openSync(inspected.absolutePath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+  try {
+    const before = fs.fstatSync(descriptor);
+    if (!workingTreeStatsMatch(expected, before)) throw new TargetChanged(relativePath);
+    const content = Buffer.allocUnsafe(before.size);
+    let offset = 0;
+    while (offset < before.size) {
+      const bytesRead = fs.readSync(descriptor, content, offset, before.size - offset, offset);
+      if (bytesRead <= 0) throw new TargetChanged(relativePath);
+      offset += bytesRead;
+    }
+    if (!workingTreeStatsMatch(expected, fs.fstatSync(descriptor))) throw new TargetChanged(relativePath);
+    return content;
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+function readOuterFile(root, relativePath) {
+  const inspected = inspectWorkingTreePath(root, relativePath);
+  if (inspected.kind !== "entry" || !inspected.stat.isFile())
+    throw new Error(`Outer worktree does not hold a regular file at ${relativePath}`);
+  return fs.readFileSync(inspected.absolutePath);
+}
+function currentTargetStat(root, relativePath) {
+  const inspected = inspectWorkingTreePath(root, relativePath);
+  return inspected.kind === "entry" ? inspected.stat : null;
+}
+function directoryHoldsOnlyVisibleEntries(root, relativePath, existing) {
+  const inspected = inspectWorkingTreePath(root, relativePath);
+  if (inspected.kind !== "entry" || !inspected.stat.isDirectory()) return true;
+  const pending = [{ absolutePath: inspected.absolutePath, relativePath }];
+  while (pending.length > 0) {
+    const directory = pending.pop();
+    for (const name of fs.readdirSync(directory.absolutePath)) {
+      const childRelative = `${directory.relativePath}/${name}`;
+      if (!existing.has(childRelative)) return false;
+      const child = fs.lstatSync(path.join(directory.absolutePath, name));
+      if (child.isDirectory() && !child.isSymbolicLink())
+        pending.push({ absolutePath: path.join(directory.absolutePath, name), relativePath: childRelative });
+    }
+  }
+  return true;
+}
+function decideWorkspaceHydrationMerge(input) {
+  const { prepared, changes, projectedFiles } = input;
+  const trustedProjection = (projected, stat) => projectedFileEntryMatches(projected, stat) && (input.readAtMs === void 0 || projected.mtimeMs < input.readAtMs - RACY_PROJECTION_WINDOW_MS && projected.ctimeMs < input.readAtMs - RACY_PROJECTION_WINDOW_MS);
+  const { desired, existing, existingStats, shielded, sourceRoot, targetRoot } = prepared;
+  const conflicts = /* @__PURE__ */ new Set();
+  const write = /* @__PURE__ */ new Set();
+  const remove = /* @__PURE__ */ new Set();
+  const overrides = /* @__PURE__ */ new Map();
+  const expectations = /* @__PURE__ */ new Map();
+  const preBlobs = /* @__PURE__ */ new Map();
+  const mergedPaths = [];
+  const keptPaths = /* @__PURE__ */ new Set();
+  const desiredForIndex = new Map(desired);
+  let algorithm = "sha1";
+  for (const change of changes.values()) {
+    const detected = gitObjectHashAlgorithmFor(change.base?.objectId ?? change.theirs?.objectId ?? "");
+    if (detected) {
+      algorithm = detected;
+      break;
+    }
+  }
+  const hashOf = (content) => gitBlobHash(content, algorithm);
+  const mergeCandidates = [];
+  const directoryReplacements = [];
+  const oursState = (relativePath, change) => {
+    const ours = existing.get(relativePath);
+    const oursStat = existingStats.get(relativePath);
+    if (!ours || !oursStat) return change.base ? "deleted" : "absent";
+    if (!change.base) return "added";
+    const base = change.base;
+    if (ours.kind === "file" && isBlobMode(base.mode)) {
+      if (executableBit(ours.mode) !== (base.mode === "100755")) return "changed";
+      const projected = projectedFiles?.[relativePath];
+      if (projected?.kind === "file" && trustedProjection(projected, oursStat)) return "base";
+      if (projectedFiles !== null && projected === void 0) return "changed";
+      return hashOf(readOwnedFile(targetRoot, relativePath, oursStat)) === base.objectId ? "base" : "changed";
+    }
+    if (ours.kind === "symlink" && base.mode === "120000") return hashOf(Buffer.from(ours.target)) === base.objectId ? "base" : "changed";
+    if (ours.kind === "gitlink" && base.mode === "160000") return ours.objectId === base.objectId ? "base" : "changed";
+    return "changed";
+  };
+  try {
+    for (const [relativePath, change] of [...changes].sort(([left], [right]) => left.localeCompare(right))) {
+      if (shielded.has(relativePath)) continue;
+      const ours = existing.get(relativePath);
+      const oursStat = existingStats.get(relativePath);
+      const theirsEntry = desired.get(relativePath);
+      if (change.theirs && (!theirsEntry || theirsEntry.kind === "directory")) {
+        conflicts.add(relativePath);
+        continue;
+      }
+      if (ours?.kind === "directory" && !change.base && change.theirs) {
+        directoryReplacements.push(relativePath);
+        continue;
+      }
+      const state = oursState(relativePath, change);
+      if (state === "base" || state === "absent") {
+        if (!change.theirs) {
+          if (ours && oursStat) {
+            remove.add(relativePath);
+            expectations.set(relativePath, oursStat);
+          }
+          if (change.base && isBlobMode(change.base.mode)) preBlobs.set(relativePath, change.base.objectId);
+          continue;
+        }
+        write.add(relativePath);
+        expectations.set(relativePath, oursStat ?? currentTargetStat(targetRoot, relativePath));
+        if (change.base && isBlobMode(change.base.mode) && change.base.objectId !== change.theirs.objectId) {
+          preBlobs.set(relativePath, change.base.objectId);
+        }
+        continue;
+      }
+      if (state === "deleted") {
+        if (change.theirs) conflicts.add(relativePath);
+        continue;
+      }
+      if (!change.theirs) {
+        conflicts.add(relativePath);
+        continue;
+      }
+      const theirs = change.theirs;
+      if (ours.kind === "file" && isBlobMode(theirs.mode)) {
+        const oursBytes = readOwnedFile(targetRoot, relativePath, oursStat);
+        const theirsBytes = readOuterFile(sourceRoot, relativePath);
+        const oursExecutable = executableBit(ours.mode);
+        const theirsExecutable = theirs.mode === "100755";
+        if (oursBytes.equals(theirsBytes)) {
+          if (oursExecutable === theirsExecutable) {
+            keptPaths.add(relativePath);
+            continue;
+          }
+          const baseExecutable = change.base ? change.base.mode === "100755" : null;
+          const resolved = baseExecutable === null ? null : resolveExecutable(baseExecutable, oursExecutable, theirsExecutable);
+          if (resolved === null) {
+            conflicts.add(relativePath);
+            continue;
+          }
+          overrides.set(relativePath, { content: theirsBytes, mode: withExecutable(oursStat.mode, resolved) });
+          write.add(relativePath);
+          expectations.set(relativePath, oursStat);
+          mergedPaths.push(relativePath);
+          continue;
+        }
+        if (!change.base || !isBlobMode(change.base.mode)) {
+          conflicts.add(relativePath);
+          continue;
+        }
+        mergeCandidates.push({
+          relativePath,
+          ours,
+          oursStat,
+          base: change.base.objectId,
+          baseExecutable: change.base.mode === "100755",
+          theirs
+        });
+        continue;
+      }
+      if (ours.kind === "symlink" && theirs.mode === "120000" && theirsEntry?.kind === "symlink") {
+        if (ours.target === theirsEntry.target) keptPaths.add(relativePath);
+        else conflicts.add(relativePath);
+        continue;
+      }
+      if (ours.kind === "gitlink" && theirs.mode === "160000") {
+        if (ours.objectId === theirs.objectId) keptPaths.add(relativePath);
+        else conflicts.add(relativePath);
+        continue;
+      }
+      conflicts.add(relativePath);
+    }
+    for (const relativePath of directoryReplacements) {
+      const prefix = `${relativePath}/`;
+      let container = true;
+      for (const candidate of existing.keys()) {
+        if (candidate.startsWith(prefix) && !remove.has(candidate)) {
+          container = false;
+          break;
+        }
+      }
+      if (container && !directoryHoldsOnlyVisibleEntries(targetRoot, relativePath, existing)) container = false;
+      if (!container) {
+        conflicts.add(relativePath);
+        continue;
+      }
+      write.add(relativePath);
+      expectations.set(relativePath, existingStats.get(relativePath) ?? null);
+    }
+    if (mergeCandidates.length > 0) {
+      const binaryPaths = input.readBinaryPaths?.(mergeCandidates.map(({ relativePath }) => relativePath));
+      const baseBlobs = input.readBaseBlobs([...new Set(mergeCandidates.map(({ base }) => base))]);
+      for (const candidate of mergeCandidates) {
+        const { relativePath } = candidate;
+        const baseBytes = baseBlobs.get(candidate.base);
+        if (!baseBytes) throw new Error(`Projected blob ${candidate.base} for ${relativePath} is missing from the workspace clone`);
+        const oursBytes = readOwnedFile(targetRoot, relativePath, candidate.oursStat);
+        const theirsBytes = readOuterFile(sourceRoot, relativePath);
+        if (binaryPaths?.has(relativePath) || isBinaryContent(baseBytes) || isBinaryContent(oursBytes) || isBinaryContent(theirsBytes)) {
+          conflicts.add(relativePath);
+          continue;
+        }
+        const merged = mergeThreeWay(baseBytes, oursBytes, theirsBytes);
+        if (merged.kind === "conflict") {
+          conflicts.add(relativePath);
+          continue;
+        }
+        const resolved = resolveExecutable(
+          candidate.baseExecutable,
+          executableBit(candidate.ours.mode),
+          candidate.theirs.mode === "100755"
+        );
+        if (resolved === null) {
+          conflicts.add(relativePath);
+          continue;
+        }
+        const mode = withExecutable(candidate.oursStat.mode, resolved);
+        const contentUnchanged = merged.content.equals(oursBytes);
+        if (contentUnchanged && mode === (candidate.oursStat.mode & 511)) {
+          keptPaths.add(relativePath);
+          continue;
+        }
+        overrides.set(relativePath, { content: merged.content, mode });
+        write.add(relativePath);
+        expectations.set(relativePath, candidate.oursStat);
+        if (!contentUnchanged) preBlobs.set(relativePath, hashOf(oursBytes));
+        mergedPaths.push(relativePath);
+      }
+    }
+    const neededDirectories = /* @__PURE__ */ new Set();
+    for (const relativePath of write) {
+      let parent = path.posix.dirname(relativePath);
+      while (parent !== ".") {
+        neededDirectories.add(parent);
+        parent = path.posix.dirname(parent);
+      }
+    }
+    for (const [relativePath, entry] of desired) {
+      if (shielded.has(relativePath) || changes.has(relativePath)) continue;
+      const current = existing.get(relativePath);
+      if (entry.kind === "directory") {
+        if (!neededDirectories.has(relativePath)) continue;
+        if (current && current.kind !== "directory") {
+          if (!remove.has(relativePath)) conflicts.add(relativePath);
+          continue;
+        }
+        expectations.set(relativePath, currentTargetStat(targetRoot, relativePath));
+        continue;
+      }
+      if (entry.kind === "gitlink") {
+        if (current?.kind === "gitlink") desiredForIndex.set(relativePath, current);
+        else {
+          const record = prepared.git?.indexRecords.find((candidate) => candidate.relativePath === relativePath && candidate.stage === 0);
+          if (record?.mode === "160000") desiredForIndex.set(relativePath, { kind: "gitlink", objectId: record.objectId });
+          else desiredForIndex.delete(relativePath);
+        }
+      }
+      if (!current || current.kind !== entry.kind) {
+        keptPaths.add(relativePath);
+        continue;
+      }
+      if (current.kind === "file") {
+        const stat = existingStats.get(relativePath);
+        const projected = projectedFiles?.[relativePath];
+        const unchanged = projected?.kind === "file" && stat ? trustedProjection(projected, stat) : projectedFiles === null || projected !== void 0;
+        if (!unchanged) keptPaths.add(relativePath);
+      }
+    }
+    for (const [relativePath, entry] of existing) {
+      if (desired.has(relativePath) || changes.has(relativePath) || entry.kind === "directory" || shielded.has(relativePath)) continue;
+      keptPaths.add(relativePath);
+    }
+    const blockedDirectories = /* @__PURE__ */ new Set();
+    for (const [relativePath, entry] of existing) {
+      if (entry.kind === "directory" || remove.has(relativePath)) continue;
+      let parent = path.posix.dirname(relativePath);
+      while (parent !== ".") {
+        blockedDirectories.add(parent);
+        parent = path.posix.dirname(parent);
+      }
+    }
+    for (const [relativePath, entry] of existing) {
+      if (entry.kind !== "directory" || desired.has(relativePath) || blockedDirectories.has(relativePath)) continue;
+      remove.add(relativePath);
+    }
+  } catch (error) {
+    if (error instanceof TargetChanged) return { kind: "target_changed", paths: [error.relativePath] };
+    throw error;
+  }
+  if (conflicts.size > 0) return { kind: "conflict", paths: [...conflicts].sort() };
+  for (const relativePath of [...write, ...overrides.keys()]) {
+    if (!expectations.has(relativePath)) expectations.set(relativePath, currentTargetStat(targetRoot, relativePath));
+  }
+  return {
+    kind: "apply",
+    selection: { write, remove, desiredForIndex },
+    overrides,
+    expectations,
+    preBlobs,
+    mergedPaths: mergedPaths.sort(),
+    keptPaths: [...keptPaths].sort()
+  };
+}
+function readHydrationBinaryPaths(input) {
+  const binary = /* @__PURE__ */ new Set();
+  if (!input.relativePaths.length) return binary;
+  const requested = new Set(input.relativePaths);
+  for (const cwd of [input.checkoutRoot, input.outerRoot]) {
+    const result = Bun.spawnSync(["git", "check-attr", "-z", "--stdin", "diff"], {
+      cwd,
+      env: workerGitProcessEnvironment(),
+      stdin: Buffer.from(`${input.relativePaths.join("\0")}\0`),
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    if (result.exitCode !== 0) throw new Error(`Cannot inspect hydration binary attributes: ${result.stderr.toString().trim()}`);
+    const records = result.stdout.toString().split("\0");
+    if (records.pop() !== "" || records.length !== requested.size * 3) throw new Error("Invalid hydration attribute response");
+    const seen = /* @__PURE__ */ new Set();
+    for (let index = 0; index < records.length; index += 3) {
+      const relativePath = records[index];
+      if (!requested.has(relativePath) || seen.has(relativePath) || records[index + 1] !== "diff")
+        throw new Error("Invalid hydration attribute path");
+      seen.add(relativePath);
+      if (records[index + 2] === "unset") binary.add(relativePath);
+    }
+  }
+  return binary;
+}
+function parseWorkspaceSubtreeChanges(raw) {
+  const changes = /* @__PURE__ */ new Map();
+  const records = [];
+  let start = 0;
+  for (let index = 0; index < raw.length; index += 1) {
+    if (raw[index] !== 0) continue;
+    if (index > start) records.push(raw.subarray(start, index));
+    start = index + 1;
+  }
+  if (start < raw.length) records.push(raw.subarray(start));
+  for (let index = 0; index + 1 < records.length; index += 2) {
+    const match = /^:([0-7]{6}) ([0-7]{6}) ([0-9a-f]{40,64}) ([0-9a-f]{40,64}) ([A-Z])/u.exec(records[index].toString());
+    if (!match) throw new Error(`Unexpected diff-tree record: ${records[index].toString()}`);
+    const relativePath = records[index + 1].toString();
+    if (relativePath.split("/").some((segment) => segment === ".." || segment === "" || segment === ".git")) {
+      throw new Error(`Unsafe path in workspace subtree diff: ${relativePath}`);
+    }
+    const base = match[1] === "000000" ? null : { mode: match[1], objectId: match[3] };
+    const theirs = match[2] === "000000" ? null : { mode: match[2], objectId: match[4] };
+    changes.set(relativePath, { base, theirs });
+  }
+  return changes;
+}
+function describeHydrationSkipPaths(mountSourcePath, paths) {
+  const shown = paths.slice(0, 5).map((relativePath) => path.join(mountSourcePath, ...relativePath.split("/")));
+  return paths.length > 5 ? `${shown.join(", ")} and ${paths.length - 5} more` : shown.join(", ");
+}
+export {
+  RACY_PROJECTION_WINDOW_MS,
+  decideWorkspaceHydrationMerge,
+  describeHydrationSkipPaths,
+  parseWorkspaceSubtreeChanges,
+  readHydrationBinaryPaths
+};

package/dist/mjs/workspace-hydration-recovery-state.mjs

@@ -0,0 +1,29 @@
+function findHydrationRecovery(error) {
+  const pending = [error];
+  const seen = /* @__PURE__ */ new Set();
+  while (pending.length) {
+    const candidate = pending.pop();
+    if (!candidate || typeof candidate !== "object" || seen.has(candidate)) continue;
+    seen.add(candidate);
+    const record = candidate;
+    if (record.code === "hydration_recovery_required" && record.hydrationRecovery && typeof record.hydrationRecovery === "object") {
+      const evidence = record.hydrationRecovery;
+      if (typeof evidence.transactionId === "string" && typeof evidence.transactionPath === "string" && Array.isArray(evidence.mounts)) {
+        const retainedPaths = [...new Set(evidence.mounts.flatMap((mount) => mount.retainedPaths ?? []))];
+        return {
+          transactionId: evidence.transactionId,
+          transactionPath: evidence.transactionPath,
+          mountIds: evidence.mounts.map(({ id }) => id),
+          previousHeads: Object.fromEntries((evidence.receiptBefore?.mounts ?? []).map(({ id, head }) => [id, head])),
+          ...retainedPaths.length > 0 ? { retainedPaths } : {}
+        };
+      }
+    }
+    pending.push(record.cause);
+    if (Array.isArray(record.errors)) pending.push(...record.errors);
+  }
+  return void 0;
+}
+export {
+  findHydrationRecovery
+};

package/dist/mjs/workspace-merge-projection.mjs

@@ -1,7 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
 import { workerGitProcessEnvironment } from "./git-process-environment.mjs";
-import { inspectWorkingTree } from "./working-tree-mirror.mjs";
+import {
+  inspectWorkingTree,
+  projectedFileEntry
+} from "./working-tree-mirror.mjs";
 import { assertManagedDirectoryPath } from "./workspace-mount-boundary.mjs";
 const MINIMUM_MERGE_TREE_GIT_VERSION = { major: 2, minor: 40 };
 const NON_RECURSIVE_GIT_CONFIG = [
@@ -142,7 +145,7 @@ function hashRegularFile(workspacePath, sourcePath, entry) {
     if (pathStatus.dev !== after.dev || pathStatus.ino !== after.ino || !pathStatus.isFile() || pathStatus.isSymbolicLink()) {
       throw new Error(`Working-tree source changed while its merge projection was being synthesized: ${sourcePath}`);
     }
-    return objectId;
+    return { objectId, projected: projectedFileEntry(after) };
   } finally {
     fs.closeSync(descriptor);
   }
@@ -175,6 +178,8 @@ function synthesizeMountTree(input) {
   const entries = inspectWorkingTree(sourceRoot, input.sourceMode);
   const indexPath = temporaryIndexPath(input.workspacePath);
   const environment = temporaryIndexEnvironment(indexPath);
+  const projectedFiles = {};
+  const blobs = /* @__PURE__ */ new Map();
   try {
     git(input.workspacePath, ["read-tree", "--empty"], "initialize workspace projection index", { environment });
     const records = [];
@@ -182,10 +187,20 @@ function synthesizeMountTree(input) {
       if (entry.kind === "directory") continue;
       if (entry.kind === "gitlink") {
         records.push(indexInfoRecord("160000", entry.objectId, relativePath));
+        projectedFiles[relativePath] = { kind: "gitlink", objectId: entry.objectId };
         continue;
       }
       const sourcePath = sourceEntryPath(sourceRoot, relativePath);
-      const objectId = entry.kind === "file" ? hashRegularFile(input.workspacePath, sourcePath, entry) : hashSymlink(input.workspacePath, sourcePath, entry);
+      let objectId;
+      if (entry.kind === "file") {
+        const hashed = hashRegularFile(input.workspacePath, sourcePath, entry);
+        objectId = hashed.objectId;
+        projectedFiles[relativePath] = hashed.projected;
+      } else {
+        objectId = hashSymlink(input.workspacePath, sourcePath, entry);
+        projectedFiles[relativePath] = { kind: "symlink", target: entry.target };
+      }
+      blobs.set(relativePath, objectId);
       records.push(indexInfoRecord(indexMode(entry), objectId, relativePath));
     }
     if (records.length > 0) {
@@ -194,14 +209,54 @@ function synthesizeMountTree(input) {
         stdin: Buffer.concat(records)
       });
     }
-    return requireObjectId(
+    const tree = requireObjectId(
       gitText(input.workspacePath, ["write-tree"], "write workspace projection mount tree", { environment }),
       "Workspace projection mount tree"
     );
+    return { tree, projectedFiles, blobs };
   } finally {
     removeTemporaryIndex(indexPath);
   }
 }
+function staleRewritePaths(input) {
+  const entries = Object.entries(input.staleRewriteBlobs ?? {});
+  if (entries.length === 0) return { stale: [], cleared: [] };
+  const probed = gitText(input.workspacePath, ["cat-file", "--batch-check"], "resolve workspace projection basis subtree", {
+    stdin: Buffer.from(`${input.basisHead}:${input.workspaceRelativePath}
+`)
+  });
+  const basisSubtree = /^([0-9a-f]{40,64}) tree \d+$/u.exec(probed);
+  if (!basisSubtree && !/ missing$/u.test(probed))
+    throw new Error(`Resolve workspace projection basis subtree: unexpected answer ${probed}`);
+  const changed = /* @__PURE__ */ new Set();
+  if (!basisSubtree) {
+    for (const relativePath of input.blobs.keys()) changed.add(relativePath);
+  } else {
+    const listing = git(
+      input.workspacePath,
+      ["diff-tree", "-r", "-z", "--no-renames", "--raw", basisSubtree[1], input.mountTree],
+      "compare workspace projection with its basis"
+    );
+    const records = nulRecords(listing);
+    for (let index = 0; index + 1 < records.length; index += 2) changed.add(records[index + 1].toString());
+  }
+  const stale = [];
+  const cleared = [];
+  for (const [relativePath, blob] of entries) {
+    const synthesized = input.blobs.get(relativePath);
+    if (synthesized === void 0) {
+      cleared.push(relativePath);
+      continue;
+    }
+    if (synthesized === blob) {
+      if (changed.has(relativePath)) stale.push(relativePath);
+      else cleared.push(relativePath);
+      continue;
+    }
+    if (changed.has(relativePath)) cleared.push(relativePath);
+  }
+  return { stale: stale.sort(), cleared: cleared.sort() };
+}
 function nulRecords(content) {
   const records = [];
   let start = 0;
@@ -249,23 +304,32 @@ function graftMountTree(input) {
   }
 }
 function synthesizeOursCommit(input) {
-  const mountTree = synthesizeMountTree({
+  const synthesized = synthesizeMountTree({
     workspacePath: input.workspacePath,
     sourcePath: input.mount.sourcePath,
     sourceMode: input.mount.sourceMode
   });
+  const detected = staleRewritePaths({
+    workspacePath: input.workspacePath,
+    workspaceRelativePath: input.workspaceRelativePath,
+    basisHead: input.basisHead,
+    mountTree: synthesized.tree,
+    blobs: synthesized.blobs,
+    staleRewriteBlobs: input.staleRewriteBlobs
+  });
+  if (detected.stale.length > 0) return { staleRewritePaths: detected.stale, staleRewriteCleared: detected.cleared };
   const rootTree = graftMountTree({
     workspacePath: input.workspacePath,
     workspaceRelativePath: input.workspaceRelativePath,
     basisHead: input.basisHead,
-    mountTree
+    mountTree: synthesized.tree
   });
   const message = JSON.stringify({
     type: "workspace_projection_basis",
     mountId: input.mount.id,
     attemptId: input.attemptId
   });
-  return requireObjectId(
+  const oursCommit = requireObjectId(
     gitText(
       input.workspacePath,
       ["commit-tree", rootTree, "-p", input.basisHead, "-m", message],
@@ -273,6 +337,7 @@ function synthesizeOursCommit(input) {
     ),
     `Synthesized workspace projection commit for mount ${input.mount.id}`
   );
+  return { oursCommit, projectedFiles: synthesized.projectedFiles, staleRewriteCleared: detected.cleared };
 }
 function mergeWorkspaceProjectionMount(input) {
   const support = workspaceMergeProjectionSupport();
@@ -281,13 +346,19 @@ function mergeWorkspaceProjectionMount(input) {
   const workspaceRelativePath = normalizeWorkspaceRelativePath(input.mount.workspaceRelativePath);
   const basisHead = requireCommit(workspacePath, input.basisHead, `workspace projection basis for mount ${input.mount.id}`);
   const currentHead = requireCommit(workspacePath, input.currentHead, "current workspace projection head");
-  const oursCommit = synthesizeOursCommit({
+  const synthesized = synthesizeOursCommit({
     workspacePath,
     mount: input.mount,
     workspaceRelativePath,
     basisHead,
-    attemptId: input.attemptId
+    attemptId: input.attemptId,
+    ...input.staleRewriteBlobs ? { staleRewriteBlobs: input.staleRewriteBlobs } : {}
   });
+  if ("staleRewritePaths" in synthesized) {
+    return { kind: "stale_rewrite", paths: synthesized.staleRewritePaths, staleRewriteCleared: synthesized.staleRewriteCleared };
+  }
+  const { oursCommit, projectedFiles, staleRewriteCleared } = synthesized;
+  const readAtMs = Date.now();
   const merged = gitResult(workspacePath, [
     "merge-tree",
     "--write-tree",
@@ -305,13 +376,16 @@ function mergeWorkspaceProjectionMount(input) {
   const records = nulRecords(merged.stdout);
   const resultTree = records.shift()?.toString() ?? "";
   requireObjectId(resultTree, `Merged workspace projection tree for mount ${input.mount.id}`);
-  if (merged.exitCode === 0) return { kind: "clean", resultTree, oursCommit };
+  if (merged.exitCode === 0) return { kind: "clean", resultTree, oursCommit, projectedFiles, readAtMs, staleRewriteCleared };
   const conflictPaths = records.map((record) => record.toString()).sort();
   return {
     kind: "conflict",
     oursCommit,
     conflictPaths,
-    error: `Workspace projection for mount ${input.mount.id} conflicted with the current workspace head`
+    error: `Workspace projection for mount ${input.mount.id} conflicted with the current workspace head`,
+    projectedFiles,
+    readAtMs,
+    staleRewriteCleared
   };
 }
 function materializeWorkspaceProjectionTree(input) {