@fern-api/replay 0.12.0 → 0.14.0

package/dist/index.js

@@ -29,9 +29,9 @@ var init_GitClient = __esm({
         return this.git.raw(args);
       }
       async execWithInput(args, input) {
-        const { spawn } = await import("child_process");
+        const { spawn: spawn2 } = await import("child_process");
         return new Promise((resolve2, reject) => {
-          const proc = spawn("git", args, { cwd: this.repoPath });
+          const proc = spawn2("git", args, { cwd: this.repoPath });
           let stdout = "";
           let stderr = "";
           proc.stdout.on("data", (data) => {
@@ -708,17 +708,57 @@ var ReplayDetector = class {
     }
     const isAncestor = await this.git.isAncestor(lastGen.commit_sha, "HEAD");
     if (!isAncestor) {
+      return this.detectPatchesViaMergeBase(lastGen, lock);
+    }
+    return this.detectPatchesInRange(lastGen.commit_sha, lastGen, lock);
+  }
+  /**
+   * FER-10201 — Non-linear-history detection via `merge-base(prevGen, HEAD)`.
+   *
+   * After a squash-merge of a Fern-bot PR, `lastGen.commit_sha` (the previous
+   * `[fern-generated]`) is orphaned but still in git's object database. The
+   * merge-base is the commit on main from which the bot's branch was created —
+   * a reachable ancestor of HEAD. Walking that range and classifying each
+   * commit via `isGenerationCommit` mirrors the linear path and eliminates
+   * the bug class where pipeline-driven changes (autoversion, replay,
+   * generation) get bundled as customer customizations.
+   *
+   * Falls through to the legacy composite path when no common ancestor exists
+   * (truly disjoint history — orphan branches with no shared root).
+   */
+  async detectPatchesViaMergeBase(lastGen, lock) {
+    let mergeBase = "";
+    try {
+      mergeBase = (await this.git.exec(["merge-base", lastGen.commit_sha, "HEAD"])).trim();
+    } catch {
+    }
+    if (!mergeBase) {
+      this.warnings.push(
+        `No common ancestor between previous generation ${lastGen.commit_sha.slice(0, 7)} and HEAD. Falling back to composite tree-diff detection.`
+      );
       return this.detectPatchesViaTreeDiff(
         lastGen,
         /* commitKnownMissing */
         false
       );
     }
+    return this.detectPatchesInRange(mergeBase, lastGen, lock);
+  }
+  /**
+   * FER-10201 — Walk `${rangeStart}..HEAD`, classify each commit, emit one
+   * `StoredPatch` per customer commit. Body shared by the linear path
+   * (rangeStart = lastGen.commit_sha) and the merge-base path.
+   *
+   * Patch `base_generation` is always `lastGen.commit_sha` — the
+   * lockfile-tracked reference the applicator uses to fetch base file
+   * content, regardless of where the walk actually started.
+   */
+  async detectPatchesInRange(rangeStart, lastGen, lock) {
     const log = await this.git.exec([
       "log",
       "--first-parent",
       "--format=%H%x00%an%x00%ae%x00%s",
-      `${lastGen.commit_sha}..HEAD`,
+      `${rangeStart}..HEAD`,
       "--",
       this.sdkOutputDir
     ]);
@@ -1218,11 +1258,43 @@ function threeWayMerge(base, ours, theirs) {
       }
     }
   }
-  return {
+  const result = {
     content: outputLines.join("\n"),
     hasConflicts: conflicts.length > 0,
     conflicts
   };
+  if (conflicts.length === 0) {
+    const dropped = computeDroppedContextLines(baseLines, theirsLines, outputLines);
+    if (dropped.length > 0) {
+      result.droppedContextLines = dropped;
+    }
+  }
+  return result;
+}
+function computeDroppedContextLines(baseLines, theirsLines, mergedLines) {
+  const baseCounts = countLines(baseLines);
+  const theirsCounts = countLines(theirsLines);
+  const mergedCounts = countLines(mergedLines);
+  const dropped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of baseLines) {
+    if (seen.has(line)) continue;
+    const inBase = baseCounts.get(line) ?? 0;
+    const inTheirs = theirsCounts.get(line) ?? 0;
+    const inMerged = mergedCounts.get(line) ?? 0;
+    if (inBase > 0 && inTheirs > 0 && inMerged < Math.min(inBase, inTheirs)) {
+      dropped.push(line);
+      seen.add(line);
+    }
+  }
+  return dropped;
+}
+function countLines(lines) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    counts.set(line, (counts.get(line) ?? 0) + 1);
+  }
+  return counts;
 }
 function tryResolveConflict(oursLines, baseLines, theirsLines) {
   if (baseLines.length === 0) {
@@ -1417,6 +1489,19 @@ var ReplayApplicator = class {
   renameCache = /* @__PURE__ */ new Map();
   treeExistsCache = /* @__PURE__ */ new Map();
   fileTheirsAccumulator = /* @__PURE__ */ new Map();
+  /**
+   * Apply mode for the current `applyPatches` invocation. Set at the start
+   * of `applyPatches`, read by `mergeFile` to decide:
+   *   - whether to skip the intra-loop marker strip (kept in `applyPatches`)
+   *   - whether to populate the accumulator after a conflicted merge
+   *     (resolve mode populates so subsequent patches on the same file
+   *     can use patch A's THEIRS as a structurally-correct merge base
+   *     when their diff was authored against post-A structure)
+   *   - whether to retry THEIRS reconstruction against the accumulator
+   *     when the BASE-relative reconstruction produced markers from a
+   *     cross-patch context mismatch
+   */
+  currentApplyMode = "replay";
   constructor(git, lockManager, outputDir) {
     this.git = git;
     this.lockManager = lockManager;
@@ -1464,8 +1549,23 @@ var ReplayApplicator = class {
   /**
    * Apply all patches, returning results for each.
    * Skips patches that match exclude patterns in replay.yml
+   *
+   * `applyMode` controls the post-conflict marker strategy:
+   *   - `"replay"` (default): strip conflict markers from disk between
+   *     iterations whenever a later patch touches the same file. Lets the
+   *     follow-up patch's `git apply --3way` see clean OURS content,
+   *     which is what the silent-loss fix (PR #73) relies on. The replay
+   *     pipeline calls `revertConflictingFiles` after the loop to clean
+   *     any markers that survive.
+   *   - `"resolve"`: keep markers on disk. The resolve command needs the
+   *     customer to see them. Slow-path 3-way merge naturally preserves
+   *     A's markers and B's clean writes when their regions don't overlap;
+   *     when they do overlap, the customer gets nested markers and
+   *     resolves manually. Either way they aren't silently dropped.
    */
-  async applyPatches(patches) {
+  async applyPatches(patches, opts) {
+    const applyMode = opts?.applyMode ?? "replay";
+    this.currentApplyMode = applyMode;
     this.resetAccumulator();
     const results = [];
     for (let i = 0; i < patches.length; i++) {
@@ -1480,7 +1580,7 @@ var ReplayApplicator = class {
       }
       const result = await this.applyPatchWithFallback(patch);
       results.push(result);
-      if (result.status === "conflict" && result.fileResults) {
+      if (applyMode !== "resolve" && result.status === "conflict" && result.fileResults) {
         const laterFiles = /* @__PURE__ */ new Set();
         for (let j = i + 1; j < patches.length; j++) {
           for (const f of patches[j].files) {
@@ -1510,9 +1610,17 @@ var ReplayApplicator = class {
     }
     return results;
   }
-  /** Populate accumulator after git apply succeeds. */
+  /**
+   * Populate accumulator after git apply succeeds, AND collect per-file
+   * results including any "dropped context lines" — lines that were
+   * present in BASE and THEIRS (unchanged context) but absent from the
+   * final on-disk state because OURS deleted them. This is the fast-path
+   * counterpart to ThreeWayMerge.computeDroppedContextLines used by the
+   * 3-way slow path; both must surface the same warning.
+   */
   async populateAccumulatorForPatch(patch, baseGen, currentTreeHash) {
-    if (!baseGen) return;
+    const fileResults = [];
+    if (!baseGen) return fileResults;
     const tempDir = await mkdtemp(join2(tmpdir(), "replay-acc-"));
     const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
     const tempGit = new GitClient2(tempDir);
@@ -1525,18 +1633,30 @@ var ReplayApplicator = class {
         const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
         const base = await this.git.showFile(baseGen.tree_hash, filePath);
         const theirs = await this.applyPatchToContent(base, patch.patch_content, filePath, tempGit, tempDir);
-        const effectiveTheirs = theirs ?? await readFile(join2(this.outputDir, resolvedPath), "utf-8").catch(() => null);
+        const finalOnDisk = await readFile(join2(this.outputDir, resolvedPath), "utf-8").catch(() => null);
+        const effectiveTheirs = theirs ?? finalOnDisk;
         if (effectiveTheirs != null) {
           this.fileTheirsAccumulator.set(resolvedPath, {
             content: effectiveTheirs,
             baseGeneration: patch.base_generation
           });
         }
+        if (base != null && effectiveTheirs != null && finalOnDisk != null) {
+          const dropped = computeDroppedContextLinesForFile(base, effectiveTheirs, finalOnDisk);
+          if (dropped.length > 0) {
+            fileResults.push({
+              file: resolvedPath,
+              status: "merged",
+              droppedContextLines: dropped
+            });
+          }
+        }
       }
     } finally {
       await rm(tempDir, { recursive: true }).catch(() => {
       });
     }
+    return fileResults;
   }
   async applyPatchWithFallback(patch) {
     const baseGen = await this.resolveBaseGeneration(patch.base_generation);
@@ -1567,11 +1687,12 @@ var ReplayApplicator = class {
       }
       try {
         await this.git.execWithInput(["apply", "--3way"], patch.patch_content);
-        await this.populateAccumulatorForPatch(patch, baseGen, currentTreeHash);
+        const fastPathFileResults = await this.populateAccumulatorForPatch(patch, baseGen, currentTreeHash);
         return {
           patch,
           status: "applied",
           method: "git-am",
+          ...fastPathFileResults.length > 0 && { fileResults: fastPathFileResults },
           ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
         };
       } catch {
@@ -1683,19 +1804,23 @@ var ReplayApplicator = class {
           renameSourcePath
         );
       }
+      const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
       if (theirs) {
         const theirsHasMarkers = theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization");
         const baseHasMarkers = base != null && (base.includes("<<<<<<< Generated") || base.includes(">>>>>>> Your customization"));
         if (theirsHasMarkers && !baseHasMarkers) {
-          return {
-            file: resolvedPath,
-            status: "skipped",
-            reason: "stale-conflict-markers"
-          };
+          if (accumulatorEntry) {
+            theirs = null;
+          } else {
+            return {
+              file: resolvedPath,
+              status: "skipped",
+              reason: "stale-conflict-markers"
+            };
+          }
         }
       }
       let useAccumulatorAsMergeBase = false;
-      const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
       if (accumulatorEntry && (theirs == null || base == null)) {
         theirs = await this.applyPatchToContent(
           accumulatorEntry.content,
@@ -1802,7 +1927,8 @@ var ReplayApplicator = class {
       const outDir = dirname2(oursPath);
       await mkdir(outDir, { recursive: true });
       await writeFile(oursPath, merged.content);
-      if (effective_theirs != null && !merged.hasConflicts) {
+      const populateAccumulator = effective_theirs != null && (!merged.hasConflicts || this.currentApplyMode === "resolve");
+      if (populateAccumulator) {
         this.fileTheirsAccumulator.set(resolvedPath, {
           content: effective_theirs,
           baseGeneration: patch.base_generation
@@ -1817,7 +1943,11 @@ var ReplayApplicator = class {
           conflictMetadata: metadata
         };
       }
-      return { file: resolvedPath, status: "merged" };
+      return {
+        file: resolvedPath,
+        status: "merged",
+        ...merged.droppedContextLines && merged.droppedContextLines.length > 0 ? { droppedContextLines: merged.droppedContextLines } : {}
+      };
     } catch (error) {
       return {
         file: filePath,
@@ -2003,6 +2133,30 @@ function isBinaryFile(filePath) {
   const ext = extname(filePath).toLowerCase();
   return BINARY_EXTENSIONS.has(ext);
 }
+function computeDroppedContextLinesForFile(base, theirs, finalContent) {
+  const baseLines = base.split("\n");
+  const theirsLines = theirs.split("\n");
+  const finalLines = finalContent.split("\n");
+  const baseCounts = /* @__PURE__ */ new Map();
+  const theirsCounts = /* @__PURE__ */ new Map();
+  const finalCounts = /* @__PURE__ */ new Map();
+  for (const l of baseLines) baseCounts.set(l, (baseCounts.get(l) ?? 0) + 1);
+  for (const l of theirsLines) theirsCounts.set(l, (theirsCounts.get(l) ?? 0) + 1);
+  for (const l of finalLines) finalCounts.set(l, (finalCounts.get(l) ?? 0) + 1);
+  const dropped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of baseLines) {
+    if (seen.has(line)) continue;
+    const inBase = baseCounts.get(line) ?? 0;
+    const inTheirs = theirsCounts.get(line) ?? 0;
+    const inFinal = finalCounts.get(line) ?? 0;
+    if (inBase > 0 && inTheirs > 0 && inFinal < Math.min(inBase, inTheirs)) {
+      dropped.push(line);
+      seen.add(line);
+    }
+  }
+  return dropped;
+}
 function isDiffLineForFile(diffLine, filePath) {
   const match = diffLine.match(/^diff --git a\/.+ b\/(.+)$/);
   return match !== null && match[1] === filePath;
@@ -2038,13 +2192,46 @@ CLI Version: ${options.cliVersion}`;
     await this.git.exec(["commit", "-m", fullMessage]);
     return (await this.git.exec(["rev-parse", "HEAD"])).trim();
   }
-  async commitReplay(_patchCount, patches, message) {
+  async commitReplay(_patchCount, patches, message, options) {
     await this.stageAll();
     if (!await this.hasStagedChanges()) {
       return (await this.git.exec(["rev-parse", "HEAD"])).trim();
     }
     let fullMessage = message ?? `[fern-replay] Applied customizations`;
-    if (patches && patches.length > 0) {
+    const buckets = options?.buckets;
+    if (buckets) {
+      if (buckets.applied.length > 0) {
+        fullMessage += `
+
+Patches applied (${buckets.applied.length}):`;
+        for (const p of buckets.applied) {
+          fullMessage += `
+  - ${p.id}: ${p.original_message}`;
+        }
+      }
+      if (buckets.unresolved.length > 0) {
+        fullMessage += `
+
+Patches with unresolved conflicts (${buckets.unresolved.length}):`;
+        for (const p of buckets.unresolved) {
+          fullMessage += `
+  - ${p.id}: ${p.original_message}`;
+        }
+        fullMessage += `
+    Run \`fern-replay resolve\` to apply these customizations.`;
+      }
+      if (buckets.absorbed.length > 0) {
+        fullMessage += `
+
+Patches absorbed by generator (${buckets.absorbed.length}):`;
+        for (const p of buckets.absorbed) {
+          fullMessage += `
+  - ${p.id}: ${p.original_message}`;
+        }
+        fullMessage += `
+    The generator now produces these customizations natively.`;
+      }
+    } else if (patches && patches.length > 0) {
       fullMessage += "\n\nPatches replayed:";
       for (const patch of patches) {
         fullMessage += `
@@ -2080,9 +2267,303 @@ CLI Version: ${options.cliVersion}`;
 
 // src/ReplayService.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { minimatch as minimatch2 } from "minimatch";
 init_GitClient();
+
+// src/PatchRegionDiff.ts
+init_HybridReconstruction();
+import { mkdtemp as mkdtemp2, writeFile as writeFile2, rm as rm2 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join3 } from "path";
+import { spawn } from "child_process";
+function normalizeHunkBody(hunk) {
+  let contextC = 0;
+  let removeC = 0;
+  let addC = 0;
+  const trimmed = [];
+  for (const line of hunk.lines) {
+    const oldUsed = contextC + removeC;
+    const newUsed = contextC + addC;
+    if (oldUsed >= hunk.oldCount && newUsed >= hunk.newCount) break;
+    trimmed.push(line);
+    if (line.type === "context") contextC++;
+    else if (line.type === "remove") removeC++;
+    else if (line.type === "add") addC++;
+  }
+  return { ...hunk, lines: trimmed };
+}
+function extractFileDiffForFile(patchContent, filePath) {
+  const lines = patchContent.split("\n");
+  const out = [];
+  let inTarget = false;
+  for (const line of lines) {
+    if (line.startsWith("diff --git")) {
+      if (inTarget) break;
+      if (isDiffLineForFile2(line, filePath)) {
+        inTarget = true;
+        out.push(line);
+      }
+      continue;
+    }
+    if (inTarget) out.push(line);
+  }
+  return out.length > 0 ? out.join("\n") + "\n" : null;
+}
+function isDiffLineForFile2(line, filePath) {
+  const match = line.match(/^diff --git a\/(.+) b\/(.+)$/);
+  return match !== null && (match[2] === filePath || match[1] === filePath);
+}
+async function computePerPatchDiff(patch, getCurrentGenContent, getWorkingTreeContent) {
+  const fragments = [];
+  const unlocatableFiles = [];
+  for (const file of patch.files) {
+    const fileDiff = extractFileDiffForFile(patch.patch_content, file);
+    if (fileDiff == null) {
+      unlocatableFiles.push(file);
+      continue;
+    }
+    const hunksRaw = parseHunks(fileDiff).map(normalizeHunkBody);
+    const hunks = hunksRaw.filter((h) => {
+      if (h.lines.length === 0) return false;
+      let ctx = 0, rm3 = 0, add = 0;
+      for (const ln of h.lines) {
+        if (ln.type === "context") ctx++;
+        else if (ln.type === "remove") rm3++;
+        else if (ln.type === "add") add++;
+      }
+      return ctx + rm3 === h.oldCount && ctx + add === h.newCount;
+    });
+    if (hunks.length === 0) {
+      if (hunksRaw.length > 0) unlocatableFiles.push(file);
+      continue;
+    }
+    const currentGen = await getCurrentGenContent(file);
+    const workingTree = await getWorkingTreeContent(file);
+    const isPureNewFile = hunks.every((h) => h.oldCount === 0);
+    const isPureDelete = hunks.every((h) => h.newCount === 0);
+    if (currentGen == null) {
+      if (!isPureNewFile) {
+        unlocatableFiles.push(file);
+        continue;
+      }
+      if (workingTree == null) continue;
+      fragments.push(synthesizeNewFileDiff(file, workingTree));
+      continue;
+    }
+    if (isPureNewFile) {
+      if (workingTree == null) {
+        fragments.push(synthesizeDeleteFileDiff(file, currentGen));
+        continue;
+      }
+      if (workingTree === currentGen) {
+        continue;
+      }
+      const fullDiff = await unifiedDiff(currentGen, workingTree, file);
+      if (fullDiff && fullDiff.trim()) fragments.push(fullDiff);
+      continue;
+    }
+    if (workingTree == null) {
+      if (!isPureDelete) {
+        unlocatableFiles.push(file);
+        continue;
+      }
+      fragments.push(synthesizeDeleteFileDiff(file, currentGen));
+      continue;
+    }
+    const currentGenLines = splitLines(currentGen);
+    const workingTreeLines = splitLines(workingTree);
+    const locInCurrentGenRaw = locateHunksInOurs(hunks, currentGenLines);
+    const locInWorkingTreeRaw = locateHunksInOurs(hunks, workingTreeLines);
+    if (locInCurrentGenRaw == null || locInWorkingTreeRaw == null) {
+      unlocatableFiles.push(file);
+      continue;
+    }
+    const locInCurrentGen = locInCurrentGenRaw.map(
+      (l) => resolveSpan(l, currentGenLines, "old")
+    );
+    const locInWorkingTree = locInWorkingTreeRaw.map(
+      (l) => resolveSpan(l, workingTreeLines, "new")
+    );
+    const overlay = overlayRegions(
+      currentGenLines,
+      locInCurrentGen,
+      workingTreeLines,
+      locInWorkingTree
+    );
+    if (overlay === null) {
+      unlocatableFiles.push(file);
+      continue;
+    }
+    if (overlay === currentGen) {
+      continue;
+    }
+    const fileUnifiedDiff = await unifiedDiff(currentGen, overlay, file);
+    if (fileUnifiedDiff && fileUnifiedDiff.trim()) {
+      fragments.push(fileUnifiedDiff);
+    }
+  }
+  return {
+    diff: fragments.join(""),
+    unlocatableFiles
+  };
+}
+async function computePerPatchDiffWithFallback(patch, getCurrentGenContent, getWorkingTreeContent, runCumulativeDiff) {
+  const ppDiff = await computePerPatchDiff(
+    patch,
+    getCurrentGenContent,
+    getWorkingTreeContent
+  );
+  if (ppDiff.unlocatableFiles.length === 0) {
+    return { diff: ppDiff.diff, hadFallback: false, fallbackFiles: [] };
+  }
+  const cumulative = await runCumulativeDiff(ppDiff.unlocatableFiles);
+  if (cumulative === null) {
+    return null;
+  }
+  const merged = ppDiff.diff + (cumulative.trim() ? cumulative : "");
+  return { diff: merged, hadFallback: true, fallbackFiles: ppDiff.unlocatableFiles };
+}
+function splitLines(content) {
+  return content.split("\n");
+}
+function resolveSpan(loc, oursLines, prefer) {
+  const { hunk, oursOffset } = loc;
+  const oldSide = [];
+  const newSide = [];
+  for (const line of hunk.lines) {
+    if (line.type === "context") {
+      oldSide.push(line.content);
+      newSide.push(line.content);
+    } else if (line.type === "remove") {
+      oldSide.push(line.content);
+    } else if (line.type === "add") {
+      newSide.push(line.content);
+    }
+  }
+  const oldFits = sequenceMatches(oldSide, oursLines, oursOffset);
+  const newFits = sequenceMatches(newSide, oursLines, oursOffset);
+  if (prefer === "old") {
+    if (oldFits) return { ...loc, oursSpan: hunk.oldCount };
+    if (newFits) return { ...loc, oursSpan: hunk.newCount };
+  } else {
+    if (newFits) return { ...loc, oursSpan: hunk.newCount };
+    if (oldFits) return { ...loc, oursSpan: hunk.oldCount };
+  }
+  return loc;
+}
+function sequenceMatches(needle, haystack, offset) {
+  if (offset + needle.length > haystack.length) return false;
+  for (let i = 0; i < needle.length; i++) {
+    if (haystack[offset + i] !== needle[i]) return false;
+  }
+  return true;
+}
+function overlayRegions(currentGenLines, locInCurrentGen, workingTreeLines, locInWorkingTree) {
+  if (locInCurrentGen.length !== locInWorkingTree.length) {
+    return null;
+  }
+  const out = [];
+  let cursor = 0;
+  for (let i = 0; i < locInCurrentGen.length; i++) {
+    const cg = locInCurrentGen[i];
+    const wt = locInWorkingTree[i];
+    if (cg.oursOffset > cursor) {
+      out.push(...currentGenLines.slice(cursor, cg.oursOffset));
+    }
+    out.push(...workingTreeLines.slice(wt.oursOffset, wt.oursOffset + wt.oursSpan));
+    cursor = cg.oursOffset + cg.oursSpan;
+  }
+  if (cursor < currentGenLines.length) {
+    out.push(...currentGenLines.slice(cursor));
+  }
+  return out.join("\n");
+}
+async function unifiedDiff(beforeContent, afterContent, filePath) {
+  if (beforeContent === afterContent) return "";
+  const tmp = await mkdtemp2(join3(tmpdir2(), "fern-replay-pp-"));
+  try {
+    const beforePath = join3(tmp, "before");
+    const afterPath = join3(tmp, "after");
+    await writeFile2(beforePath, beforeContent, "utf-8");
+    await writeFile2(afterPath, afterContent, "utf-8");
+    const raw = await runGitDiffNoIndex(beforePath, afterPath);
+    if (!raw.trim()) return "";
+    return rewriteDiffHeaders(raw, filePath);
+  } finally {
+    await rm2(tmp, { recursive: true, force: true });
+  }
+}
+function runGitDiffNoIndex(beforePath, afterPath) {
+  return new Promise((resolve2, reject) => {
+    const proc = spawn("git", ["diff", "--no-index", "--", beforePath, afterPath]);
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (d) => stdout += d.toString());
+    proc.stderr.on("data", (d) => stderr += d.toString());
+    proc.on("close", (code) => {
+      if (code === 0 || code === 1) resolve2(stdout);
+      else reject(new Error(`git diff --no-index failed (code ${code}): ${stderr}`));
+    });
+  });
+}
+function rewriteDiffHeaders(raw, filePath) {
+  const lines = raw.split("\n");
+  const out = [];
+  let seenFirstHeader = false;
+  for (const line of lines) {
+    if (line.startsWith("diff --git ")) {
+      out.push(`diff --git a/${filePath} b/${filePath}`);
+      seenFirstHeader = true;
+      continue;
+    }
+    if (!seenFirstHeader) {
+      continue;
+    }
+    if (line.startsWith("--- ")) {
+      out.push(`--- a/${filePath}`);
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      out.push(`+++ b/${filePath}`);
+      continue;
+    }
+    out.push(line);
+  }
+  return out.join("\n");
+}
+function synthesizeNewFileDiff(file, content) {
+  const lines = content.split("\n");
+  const hasTrailingNewline = content.endsWith("\n");
+  const bodyLines = hasTrailingNewline ? lines.slice(0, -1) : lines;
+  const header = [
+    `diff --git a/${file} b/${file}`,
+    "new file mode 100644",
+    "--- /dev/null",
+    `+++ b/${file}`,
+    `@@ -0,0 +1,${bodyLines.length} @@`
+  ].join("\n");
+  const body = bodyLines.map((l) => `+${l}`).join("\n");
+  const trailer = hasTrailingNewline ? "" : "\n\";
+  return header + "\n" + body + trailer + "\n";
+}
+function synthesizeDeleteFileDiff(file, content) {
+  const lines = content.split("\n");
+  const hasTrailingNewline = content.endsWith("\n");
+  const bodyLines = hasTrailingNewline ? lines.slice(0, -1) : lines;
+  const header = [
+    `diff --git a/${file} b/${file}`,
+    "deleted file mode 100644",
+    `--- a/${file}`,
+    "+++ /dev/null",
+    `@@ -1,${bodyLines.length} +0,0 @@`
+  ].join("\n");
+  const body = bodyLines.map((l) => `-${l}`).join("\n");
+  const trailer = hasTrailingNewline ? "" : "\n\";
+  return header + "\n" + body + trailer + "\n";
+}
+
+// src/ReplayService.ts
 var ReplayService = class {
   git;
   detector;
@@ -2476,6 +2957,7 @@ var ReplayService = class {
     if (newPatches.length > 0) {
       results = await this.applicator.applyPatches(newPatches);
       this._lastApplyResults = results;
+      this.recordDroppedContextLineWarnings(results);
       this.revertConflictingFiles(results);
       for (const result of results) {
         if (result.status === "conflict") {
@@ -2494,7 +2976,8 @@ var ReplayService = class {
     if (newPatches.length > 0) {
       if (!options?.stageOnly) {
         const appliedCount = results.filter((r) => r.status === "applied").length;
-        await this.committer.commitReplay(appliedCount, newPatches);
+        const buckets = computeCommitBuckets(results, rebaseCounts.absorbedPatchIds, newPatches);
+        await this.committer.commitReplay(appliedCount, newPatches, void 0, { buckets });
       } else {
         await this.committer.stageAll();
       }
@@ -2557,12 +3040,21 @@ var ReplayService = class {
       (p) => preRebasePatchIds.has(p.id) && !postRebasePatchIds.has(p.id)
     );
     existingPatches = this.lockManager.getPatches();
-    const seenHashes = /* @__PURE__ */ new Set();
+    const seenHashes = /* @__PURE__ */ new Map();
     for (const p of existingPatches) {
-      if (seenHashes.has(p.content_hash)) {
-        this.lockManager.removePatch(p.id);
+      const priorOrigin = seenHashes.get(p.content_hash);
+      if (priorOrigin !== void 0) {
+        const provenanceMissing = !priorOrigin || !p.original_commit;
+        const sameOrigin = priorOrigin === p.original_commit;
+        if (sameOrigin && !provenanceMissing) {
+          this.lockManager.removePatch(p.id);
+        } else {
+          this.warnings.push(
+            `Preserving patch ${p.id} (commit ${(p.original_commit || "<missing>").slice(0, 7)}): shares content_hash with a prior patch ${provenanceMissing ? "(provenance missing on at least one side)" : "from a different source commit"}. Both retained to avoid silent customization loss (FER-9983).`
+          );
+        }
       } else {
-        seenHashes.add(p.content_hash);
+        seenHashes.set(p.content_hash, p.original_commit);
       }
     }
     existingPatches = this.lockManager.getPatches();
@@ -2623,6 +3115,7 @@ var ReplayService = class {
     const genSha = prep._prepared.genSha;
     const results = await this.applicator.applyPatches(allPatches);
     this._lastApplyResults = results;
+    this.recordDroppedContextLineWarnings(results);
     this.revertConflictingFiles(results);
     for (const result of results) {
       if (result.status === "conflict") {
@@ -2650,7 +3143,8 @@ var ReplayService = class {
       await this.committer.stageAll();
     } else {
       const appliedCount = results.filter((r) => r.status === "applied").length;
-      await this.committer.commitReplay(appliedCount, allPatches);
+      const buckets = computeCommitBuckets(results, rebaseCounts.absorbedPatchIds, allPatches);
+      await this.committer.commitReplay(appliedCount, allPatches, void 0, { buckets });
     }
     const warnings = [...detectorWarnings, ...this.warnings];
     return this.buildReport(
@@ -2674,7 +3168,7 @@ var ReplayService = class {
     let repointed = 0;
     let contentRebased = 0;
     let keptAsUserOwned = 0;
-    const seenContentHashes = /* @__PURE__ */ new Set();
+    const seenContentHashes = /* @__PURE__ */ new Map();
     const absorbedPatchIds = /* @__PURE__ */ new Set();
     const fernignorePatterns = this.readFernignorePatterns();
     for (const result of results) {
@@ -2688,6 +3182,23 @@ var ReplayService = class {
         }
       }
     }
+    const conflictedFilePaths = /* @__PURE__ */ new Set();
+    for (const r of results) {
+      if (r.status !== "conflict") continue;
+      if (r.fileResults) {
+        for (const fr of r.fileResults) {
+          if (fr.status !== "conflict") continue;
+          conflictedFilePaths.add(fr.file);
+          if (r.resolvedFiles) {
+            for (const [orig, resolved] of Object.entries(r.resolvedFiles)) {
+              if (resolved === fr.file) conflictedFilePaths.add(orig);
+            }
+          }
+        }
+      } else {
+        for (const f of r.patch.files) conflictedFilePaths.add(f);
+      }
+    }
     for (const result of results) {
       if (result.status === "conflict" && result.fileResults) {
         await this.trimAbsorbedFiles(result, currentGenSha);
@@ -2755,6 +3266,18 @@ var ReplayService = class {
             keptAsUserOwned++;
             continue;
           }
+          const overlapsConflicted = patch.files.some((f) => conflictedFilePaths.has(f));
+          if (overlapsConflicted) {
+            patch.status = "unresolved";
+            try {
+              this.lockManager.updatePatch(patch.id, { status: "unresolved" });
+            } catch {
+            }
+            this.warnings.push(
+              `Patch ${patch.id} (${patch.original_message}) was preserved as unresolved because an earlier patch conflicted on the same file(s) (${patch.files.join(", ")}). Run \`fern replay resolve\` to apply this customization manually.`
+            );
+            continue;
+          }
           this.lockManager.removePatch(patch.id);
           absorbedPatchIds.add(patch.id);
           absorbed++;
@@ -2770,13 +3293,22 @@ var ReplayService = class {
           continue;
         }
         const newContentHash = this.detector.computeContentHash(diff);
-        if (seenContentHashes.has(newContentHash)) {
-          this.lockManager.removePatch(patch.id);
-          absorbedPatchIds.add(patch.id);
-          absorbed++;
-          continue;
+        const priorOrigin = seenContentHashes.get(newContentHash);
+        if (priorOrigin !== void 0) {
+          const provenanceMissing = !priorOrigin || !patch.original_commit;
+          const sameOrigin = priorOrigin === patch.original_commit;
+          if (sameOrigin && !provenanceMissing) {
+            this.lockManager.removePatch(patch.id);
+            absorbedPatchIds.add(patch.id);
+            absorbed++;
+            continue;
+          }
+          this.warnings.push(
+            `Preserving patch ${patch.id} (commit ${(patch.original_commit || "<missing>").slice(0, 7)}): shares content_hash with a prior patch ${provenanceMissing ? "(provenance missing on at least one side)" : "from a different source commit"}. Both retained to avoid silent customization loss (FER-9983).`
+          );
+        } else {
+          seenContentHashes.set(newContentHash, patch.original_commit);
         }
-        seenContentHashes.add(newContentHash);
         patch.base_generation = currentGenSha;
         patch.patch_content = diff;
         patch.content_hash = newContentHash;
@@ -2952,8 +3484,14 @@ var ReplayService = class {
       }
       if (patch.base_generation === currentGen) {
         try {
-          const diff = await this.git.exec(["diff", currentGen, "HEAD", "--", ...patch.files]).catch(() => null);
-          if (diff === null) continue;
+          const ppResult = await computePerPatchDiffWithFallback(
+            patch,
+            (f) => this.git.showFile(currentGen, f),
+            (f) => this.git.showFile("HEAD", f),
+            (files) => this.git.exec(["diff", currentGen, "HEAD", "--", ...files]).catch(() => null)
+          );
+          if (ppResult === null) continue;
+          const diff = ppResult.diff;
           if (!diff.trim()) {
             if (await allPatchFilesUserOwned(patch)) continue;
             this.lockManager.removePatch(patch.id);
@@ -2995,8 +3533,14 @@ var ReplayService = class {
       try {
         const markerFiles = await this.git.exec(["grep", "-l", "<<<<<<< Generated", "HEAD", "--", ...patch.files]).catch(() => "");
         if (markerFiles.trim()) continue;
-        const diff = await this.git.exec(["diff", currentGen, "HEAD", "--", ...patch.files]).catch(() => null);
-        if (diff === null) continue;
+        const ppResult = await computePerPatchDiffWithFallback(
+          patch,
+          (f) => this.git.showFile(currentGen, f),
+          (f) => this.git.showFile("HEAD", f),
+          (files) => this.git.exec(["diff", currentGen, "HEAD", "--", ...files]).catch(() => null)
+        );
+        if (ppResult === null) continue;
+        const diff = ppResult.diff;
         if (!diff.trim()) {
           if (await allPatchFilesUserOwned(patch)) {
             try {
@@ -3021,6 +3565,32 @@ var ReplayService = class {
     }
     return { conflictResolved, conflictAbsorbed, contentRefreshed };
   }
+  /**
+   * After applyPatches(), surface a warning for each (patch × file) where
+   * diff3 silently dropped lines that were unchanged context in the
+   * customer's THEIRS. The deletion stays on disk (correct diff3 outcome),
+   * but the customer must learn so they can re-add the lines if they
+   * relied on them. This is the "surface or preserve, never silently drop"
+   * contract for legitimate-deletion cases.
+   */
+  recordDroppedContextLineWarnings(results) {
+    const PREVIEW_COUNT = 5;
+    for (const result of results) {
+      if (!result.fileResults) continue;
+      for (const fr of result.fileResults) {
+        const dropped = fr.droppedContextLines;
+        if (!dropped || dropped.length === 0) continue;
+        const preview = dropped.slice(0, PREVIEW_COUNT).map((line) => `    ${line}`).join("\n");
+        const more = dropped.length > PREVIEW_COUNT ? `
+    ... and ${dropped.length - PREVIEW_COUNT} more` : "";
+        this.warnings.push(
+          `${fr.file}: ${dropped.length} line(s) that appeared as unchanged context in your customization were deleted by the new generator output. The merge followed the deletion. First lines deleted:
+${preview}${more}
+If you want to keep these lines, restore them in a follow-up commit and re-run replay; otherwise this warning can be safely ignored.`
+        );
+      }
+    }
+  }
   /**
    * After applyPatches(), strip conflict markers from conflicting files
    * so only clean content is committed. Keeps the Generated (OURS) side.
@@ -3030,7 +3600,7 @@ var ReplayService = class {
       if (result.status !== "conflict" || !result.fileResults) continue;
       for (const fileResult of result.fileResults) {
         if (fileResult.status !== "conflict") continue;
-        const filePath = join3(this.outputDir, fileResult.file);
+        const filePath = join4(this.outputDir, fileResult.file);
         try {
           const content = readFileSync2(filePath, "utf-8");
           const stripped = stripConflictMarkers(content);
@@ -3060,7 +3630,7 @@ var ReplayService = class {
     }
   }
   readFernignorePatterns() {
-    const fernignorePath = join3(this.outputDir, ".fernignore");
+    const fernignorePath = join4(this.outputDir, ".fernignore");
     if (!existsSync2(fernignorePath)) return [];
     return readFileSync2(fernignorePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   }
@@ -3078,6 +3648,9 @@ var ReplayService = class {
       };
     }).filter((d) => d.files.length > 0);
     const partialCount = conflictDetails.filter((d) => d.cleanFiles && d.cleanFiles.length > 0).length;
+    const unresolvedResults = results.filter(
+      (r) => r.status === "conflict" || r.patch.status === "unresolved"
+    );
     return {
       flow,
       patchesDetected: patches.length,
@@ -3094,7 +3667,7 @@ var ReplayService = class {
       patchesRefreshed: preRebaseCounts && preRebaseCounts.contentRefreshed > 0 ? preRebaseCounts.contentRefreshed : void 0,
       conflicts: conflictResults.flatMap((r) => r.fileResults?.filter((f) => f.status === "conflict") ?? []),
       conflictDetails: conflictDetails.length > 0 ? conflictDetails : void 0,
-      unresolvedPatches: conflictResults.length > 0 ? conflictResults.map((r) => ({
+      unresolvedPatches: unresolvedResults.length > 0 ? unresolvedResults.map((r) => ({
         patchId: r.patch.id,
         patchMessage: r.patch.original_message,
         files: r.patch.files,
@@ -3105,11 +3678,38 @@ var ReplayService = class {
     };
   }
 };
+function computeCommitBuckets(results, absorbedPatchIds, patchesPassedToCommit) {
+  const resultByPatchId = /* @__PURE__ */ new Map();
+  for (const r of results) resultByPatchId.set(r.patch.id, r);
+  const applied = [];
+  const unresolved = [];
+  const absorbed = [];
+  for (const patch of patchesPassedToCommit) {
+    if (absorbedPatchIds.has(patch.id)) {
+      absorbed.push(patch);
+      continue;
+    }
+    const r = resultByPatchId.get(patch.id);
+    if (!r) {
+      applied.push(patch);
+      continue;
+    }
+    if (r.status === "conflict" || patch.status === "unresolved") {
+      unresolved.push(patch);
+      continue;
+    }
+    if (r.status === "applied") {
+      applied.push(patch);
+      continue;
+    }
+  }
+  return { applied, unresolved, absorbed };
+}
 
 // src/FernignoreMigrator.ts
 import { createHash as createHash2 } from "crypto";
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, statSync, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname3, join as join4 } from "path";
+import { dirname as dirname3, join as join5 } from "path";
 import { minimatch as minimatch3 } from "minimatch";
 import { parse as parse2, stringify as stringify2 } from "yaml";
 var FernignoreMigrator = class {
@@ -3122,10 +3722,10 @@ var FernignoreMigrator = class {
     this.outputDir = outputDir;
   }
   fernignoreExists() {
-    return existsSync3(join4(this.outputDir, ".fernignore"));
+    return existsSync3(join5(this.outputDir, ".fernignore"));
   }
   readFernignorePatterns() {
-    const fernignorePath = join4(this.outputDir, ".fernignore");
+    const fernignorePath = join5(this.outputDir, ".fernignore");
     if (!existsSync3(fernignorePath)) {
       return [];
     }
@@ -3185,7 +3785,16 @@ var FernignoreMigrator = class {
             original_author: "Fern Replay <replay@buildwithfern.com>",
             base_generation: currentGen.commit_sha,
             files: patchFiles,
-            patch_content: patchContent
+            patch_content: patchContent,
+            // Synthetic patches captured from .fernignore-protected files
+            // are user-owned by definition — the customer's content
+            // diverges from the generator's pristine output, and the
+            // generator never produced this divergent content. Without
+            // this flag, removing the file from .fernignore later (so
+            // it leaves the protection check in `isFileUserOwned`) would
+            // expose the patch to absorption on the next regen,
+            // silently losing the customization.
+            user_owned: true
           });
           trackedByBoth.push({
             file: pattern,
@@ -3218,7 +3827,7 @@ var FernignoreMigrator = class {
     return results;
   }
   readFileContent(filePath) {
-    const fullPath = join4(this.outputDir, filePath);
+    const fullPath = join5(this.outputDir, filePath);
     if (!existsSync3(fullPath)) {
       return null;
     }
@@ -3283,7 +3892,7 @@ var FernignoreMigrator = class {
     };
   }
   movePatternsToReplayYml(patterns) {
-    const replayYmlPath = join4(this.outputDir, ".fern", "replay.yml");
+    const replayYmlPath = join5(this.outputDir, ".fern", "replay.yml");
     let config = {};
     if (existsSync3(replayYmlPath)) {
       const content = readFileSync3(replayYmlPath, "utf-8");
@@ -3303,7 +3912,7 @@ var FernignoreMigrator = class {
 // src/commands/bootstrap.ts
 import { createHash as createHash3 } from "crypto";
 import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 init_GitClient();
 async function bootstrap(outputDir, options) {
   const git = new GitClient(outputDir);
@@ -3470,7 +4079,7 @@ function parseGitLog(log) {
 }
 var REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml", ".gitattributes"];
 function ensureFernignoreEntries(outputDir) {
-  const fernignorePath = join5(outputDir, ".fernignore");
+  const fernignorePath = join6(outputDir, ".fernignore");
   let content = "";
   if (existsSync4(fernignorePath)) {
     content = readFileSync4(fernignorePath, "utf-8");
@@ -3494,7 +4103,7 @@ function ensureFernignoreEntries(outputDir) {
 }
 var GITATTRIBUTES_ENTRIES = [".fern/replay.lock linguist-generated=true"];
 function ensureGitattributesEntries(outputDir) {
-  const gitattributesPath = join5(outputDir, ".gitattributes");
+  const gitattributesPath = join6(outputDir, ".gitattributes");
   let content = "";
   if (existsSync4(gitattributesPath)) {
     content = readFileSync4(gitattributesPath, "utf-8");
@@ -3693,6 +4302,8 @@ function reset(outputDir, options) {
 
 // src/commands/resolve.ts
 init_GitClient();
+import { readFile as readFile2 } from "fs/promises";
+import { join as join7 } from "path";
 async function resolve(outputDir, options) {
   const lockManager = new LockfileManager(outputDir);
   if (!lockManager.exists()) {
@@ -3707,7 +4318,7 @@ async function resolve(outputDir, options) {
   const resolvingPatches = lockManager.getResolvingPatches();
   if (unresolvedPatches.length > 0) {
     const applicator = new ReplayApplicator(git, lockManager, outputDir);
-    await applicator.applyPatches(unresolvedPatches);
+    await applicator.applyPatches(unresolvedPatches, { applyMode: "resolve" });
     const markerFiles = await findConflictMarkerFiles(git);
     if (markerFiles.length > 0) {
       for (const patch of unresolvedPatches) {
@@ -3733,20 +4344,38 @@ async function resolve(outputDir, options) {
   if (patchesToCommit.length > 0) {
     const currentGen = lock.current_generation;
     const detector = new ReplayDetector(git, lockManager, outputDir);
+    const warnings = [];
     let patchesResolved = 0;
     for (const patch of patchesToCommit) {
-      const diff = await git.exec(["diff", currentGen, "--", ...patch.files]).catch(() => null);
-      if (!diff || !diff.trim()) {
+      const result = await computePerPatchDiffWithFallback(
+        patch,
+        (f) => git.showFile(currentGen, f),
+        (f) => readFile2(join7(outputDir, f), "utf-8").catch(() => null),
+        (files) => git.exec(["diff", currentGen, "--", ...files]).catch(() => null)
+      );
+      if (result === null) {
+        warnings.push(
+          `Patch ${patch.id}: cumulative-diff fallback failed for unlocatable files; preserving patch unchanged`
+        );
+        continue;
+      }
+      const diff = result.diff;
+      if (!diff.trim()) {
         lockManager.removePatch(patch.id);
         continue;
       }
+      if (result.hadFallback) {
+        warnings.push(
+          `Patch ${patch.id}: ${result.fallbackFiles.join(", ")} could not be anchored; cumulative-diff fallback applied for those files`
+        );
+      }
       const newContentHash = detector.computeContentHash(diff);
-      const changedFiles = await getChangedFiles(git, currentGen, patch.files);
+      const changedFiles = result.hadFallback ? await getChangedFiles(git, currentGen, patch.files) : extractFilesFromDiff(diff);
       lockManager.markPatchResolved(patch.id, {
         patch_content: diff,
         content_hash: newContentHash,
         base_generation: currentGen,
-        files: changedFiles
+        files: changedFiles.length > 0 ? changedFiles : patch.files
       });
       patchesResolved++;
     }
@@ -3762,7 +4391,8 @@ async function resolve(outputDir, options) {
       success: true,
       commitSha: commitSha2,
       phase: "committed",
-      patchesResolved
+      patchesResolved,
+      warnings: warnings.length > 0 ? warnings : void 0
     };
   }
   const committer = new ReplayCommitter(git, outputDir);
@@ -3780,6 +4410,24 @@ async function getChangedFiles(git, currentGen, files) {
   const changed = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !f.startsWith(".fern/"));
   return changed.length > 0 ? changed : files;
 }
+function extractFilesFromDiff(unifiedDiff2) {
+  const out = /* @__PURE__ */ new Set();
+  const renameSources = /* @__PURE__ */ new Set();
+  let currentTarget = null;
+  for (const line of unifiedDiff2.split("\n")) {
+    const headerMatch = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+    if (headerMatch) {
+      currentTarget = headerMatch[2];
+      if (!currentTarget.startsWith(".fern/")) out.add(currentTarget);
+      continue;
+    }
+    if (currentTarget && line.startsWith("rename from ")) {
+      renameSources.add(line.slice("rename from ".length));
+    }
+  }
+  for (const src of renameSources) out.delete(src);
+  return Array.from(out);
+}
 
 // src/commands/status.ts
 function status(outputDir) {