@fern-api/fern-api-dev 5.0.0-6-gb0a2ec4ace2 → 5.1.0

package/cli.cjs

@@ -340394,9 +340394,9 @@ var require_diff3 = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/@fern-api+replay@0.13.0/node_modules/@fern-api/replay/dist/index.cjs
+// ../../../node_modules/.pnpm/@fern-api+replay@0.14.0/node_modules/@fern-api/replay/dist/index.cjs
 var require_dist14 = __commonJS({
-  "../../../node_modules/.pnpm/@fern-api+replay@0.13.0/node_modules/@fern-api/replay/dist/index.cjs"(exports2, module4) {
+  "../../../node_modules/.pnpm/@fern-api+replay@0.14.0/node_modules/@fern-api/replay/dist/index.cjs"(exports2, module4) {
     "use strict";
     var __defProp4 = Object.defineProperty;
     var __getOwnPropDesc4 = Object.getOwnPropertyDescriptor;
@@ -340439,9 +340439,9 @@ var require_dist14 = __commonJS({
             return this.git.raw(args);
           }
           async execWithInput(args, input3) {
-            const { spawn: spawn7 } = await import("child_process");
+            const { spawn: spawn22 } = await import("child_process");
             return new Promise((resolve22, reject) => {
-              const proc2 = spawn7("git", args, { cwd: this.repoPath });
+              const proc2 = spawn22("git", args, { cwd: this.repoPath });
               let stdout = "";
               let stderr = "";
               proc2.stdout.on("data", (data2) => {
@@ -341684,11 +341684,43 @@ var require_dist14 = __commonJS({
           }
         }
       }
-      return {
+      const result = {
         content: outputLines.join("\n"),
         hasConflicts: conflicts2.length > 0,
         conflicts: conflicts2
       };
+      if (conflicts2.length === 0) {
+        const dropped = computeDroppedContextLines(baseLines, theirsLines, outputLines);
+        if (dropped.length > 0) {
+          result.droppedContextLines = dropped;
+        }
+      }
+      return result;
+    }
+    function computeDroppedContextLines(baseLines, theirsLines, mergedLines) {
+      const baseCounts = countLines2(baseLines);
+      const theirsCounts = countLines2(theirsLines);
+      const mergedCounts = countLines2(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 countLines2(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) {
@@ -341877,6 +341909,19 @@ var require_dist14 = __commonJS({
       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;
@@ -341924,8 +341969,23 @@ var require_dist14 = __commonJS({
       /**
        * Apply all patches, returning results for each.
        * Skips patches that match exclude patterns in replay.yml
-       */
-      async applyPatches(patches) {
+       *
+       * `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, opts) {
+        const applyMode = opts?.applyMode ?? "replay";
+        this.currentApplyMode = applyMode;
         this.resetAccumulator();
         const results = [];
         for (let i9 = 0; i9 < patches.length; i9++) {
@@ -341940,7 +342000,7 @@ var require_dist14 = __commonJS({
           }
           const result = await this.applyPatchWithFallback(patch5);
           results.push(result);
-          if (result.status === "conflict" && result.fileResults) {
+          if (applyMode !== "resolve" && result.status === "conflict" && result.fileResults) {
             const laterFiles = /* @__PURE__ */ new Set();
             for (let j7 = i9 + 1; j7 < patches.length; j7++) {
               for (const f5 of patches[j7].files) {
@@ -341970,9 +342030,17 @@ var require_dist14 = __commonJS({
         }
         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(patch5, baseGen, currentTreeHash) {
-        if (!baseGen) return;
+        const fileResults = [];
+        if (!baseGen) return fileResults;
         const tempDir2 = await (0, import_promises192.mkdtemp)((0, import_node_path210.join)((0, import_node_os15.tmpdir)(), "replay-acc-"));
         const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
         const tempGit = new GitClient2(tempDir2);
@@ -341985,18 +342053,30 @@ var require_dist14 = __commonJS({
             const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
             const base4 = await this.git.showFile(baseGen.tree_hash, filePath);
             const theirs = await this.applyPatchToContent(base4, patch5.patch_content, filePath, tempGit, tempDir2);
-            const effectiveTheirs = theirs ?? await (0, import_promises192.readFile)((0, import_node_path210.join)(this.outputDir, resolvedPath), "utf-8").catch(() => null);
+            const finalOnDisk = await (0, import_promises192.readFile)((0, import_node_path210.join)(this.outputDir, resolvedPath), "utf-8").catch(() => null);
+            const effectiveTheirs = theirs ?? finalOnDisk;
             if (effectiveTheirs != null) {
               this.fileTheirsAccumulator.set(resolvedPath, {
                 content: effectiveTheirs,
                 baseGeneration: patch5.base_generation
               });
             }
+            if (base4 != null && effectiveTheirs != null && finalOnDisk != null) {
+              const dropped = computeDroppedContextLinesForFile(base4, effectiveTheirs, finalOnDisk);
+              if (dropped.length > 0) {
+                fileResults.push({
+                  file: resolvedPath,
+                  status: "merged",
+                  droppedContextLines: dropped
+                });
+              }
+            }
           }
         } finally {
           await (0, import_promises192.rm)(tempDir2, { recursive: true }).catch(() => {
           });
         }
+        return fileResults;
       }
       async applyPatchWithFallback(patch5) {
         const baseGen = await this.resolveBaseGeneration(patch5.base_generation);
@@ -342027,11 +342107,12 @@ var require_dist14 = __commonJS({
           }
           try {
             await this.git.execWithInput(["apply", "--3way"], patch5.patch_content);
-            await this.populateAccumulatorForPatch(patch5, baseGen, currentTreeHash);
+            const fastPathFileResults = await this.populateAccumulatorForPatch(patch5, baseGen, currentTreeHash);
             return {
               patch: patch5,
               status: "applied",
               method: "git-am",
+              ...fastPathFileResults.length > 0 && { fileResults: fastPathFileResults },
               ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
             };
           } catch {
@@ -342143,19 +342224,23 @@ var require_dist14 = __commonJS({
               renameSourcePath
             );
           }
+          const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
           if (theirs) {
             const theirsHasMarkers = theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization");
             const baseHasMarkers = base4 != null && (base4.includes("<<<<<<< Generated") || base4.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 || base4 == null)) {
             theirs = await this.applyPatchToContent(
               accumulatorEntry.content,
@@ -342262,7 +342347,8 @@ var require_dist14 = __commonJS({
           const outDir = (0, import_node_path210.dirname)(oursPath);
           await (0, import_promises192.mkdir)(outDir, { recursive: true });
           await (0, import_promises192.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: patch5.base_generation
@@ -342277,7 +342363,11 @@ var require_dist14 = __commonJS({
               conflictMetadata: metadata
             };
           }
-          return { file: resolvedPath, status: "merged" };
+          return {
+            file: resolvedPath,
+            status: "merged",
+            ...merged.droppedContextLines && merged.droppedContextLines.length > 0 ? { droppedContextLines: merged.droppedContextLines } : {}
+          };
         } catch (error50) {
           return {
             file: filePath,
@@ -342463,6 +342553,30 @@ var require_dist14 = __commonJS({
       const ext2 = (0, import_node_path210.extname)(filePath).toLowerCase();
       return BINARY_EXTENSIONS2.has(ext2);
     }
+    function computeDroppedContextLinesForFile(base4, theirs, finalContent) {
+      const baseLines = base4.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 l9 of baseLines) baseCounts.set(l9, (baseCounts.get(l9) ?? 0) + 1);
+      for (const l9 of theirsLines) theirsCounts.set(l9, (theirsCounts.get(l9) ?? 0) + 1);
+      for (const l9 of finalLines) finalCounts.set(l9, (finalCounts.get(l9) ?? 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 match3 = diffLine.match(/^diff --git a\/.+ b\/(.+)$/);
       return match3 !== null && match3[1] === filePath;
@@ -342496,13 +342610,46 @@ CLI Version: ${options2.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, options2) {
         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 = options2?.buckets;
+        if (buckets) {
+          if (buckets.applied.length > 0) {
+            fullMessage += `
+
+Patches applied (${buckets.applied.length}):`;
+            for (const p14 of buckets.applied) {
+              fullMessage += `
+  - ${p14.id}: ${p14.original_message}`;
+            }
+          }
+          if (buckets.unresolved.length > 0) {
+            fullMessage += `
+
+Patches with unresolved conflicts (${buckets.unresolved.length}):`;
+            for (const p14 of buckets.unresolved) {
+              fullMessage += `
+  - ${p14.id}: ${p14.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 p14 of buckets.absorbed) {
+              fullMessage += `
+  - ${p14.id}: ${p14.original_message}`;
+            }
+            fullMessage += `
+    The generator now produces these customizations natively.`;
+          }
+        } else if (patches && patches.length > 0) {
           fullMessage += "\n\nPatches replayed:";
           for (const patch5 of patches) {
             fullMessage += `
@@ -342536,9 +342683,299 @@ CLI Version: ${options2.cliVersion}`;
       }
     };
     var import_node_fs210 = require("fs");
-    var import_node_path310 = require("path");
+    var import_node_path43 = require("path");
     var import_minimatch22 = require_commonjs3();
     init_GitClient();
+    var import_promises210 = require("fs/promises");
+    var import_node_os22 = require("os");
+    var import_node_path310 = require("path");
+    var import_node_child_process7 = require("child_process");
+    init_HybridReconstruction();
+    function normalizeHunkBody(hunk) {
+      let contextC = 0;
+      let removeC = 0;
+      let addC = 0;
+      const trimmed2 = [];
+      for (const line of hunk.lines) {
+        const oldUsed = contextC + removeC;
+        const newUsed = contextC + addC;
+        if (oldUsed >= hunk.oldCount && newUsed >= hunk.newCount) break;
+        trimmed2.push(line);
+        if (line.type === "context") contextC++;
+        else if (line.type === "remove") removeC++;
+        else if (line.type === "add") addC++;
+      }
+      return { ...hunk, lines: trimmed2 };
+    }
+    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 match3 = line.match(/^diff --git a\/(.+) b\/(.+)$/);
+      return match3 !== null && (match3[2] === filePath || match3[1] === filePath);
+    }
+    async function computePerPatchDiff(patch5, getCurrentGenContent, getWorkingTreeContent) {
+      const fragments = [];
+      const unlocatableFiles = [];
+      for (const file4 of patch5.files) {
+        const fileDiff = extractFileDiffForFile(patch5.patch_content, file4);
+        if (fileDiff == null) {
+          unlocatableFiles.push(file4);
+          continue;
+        }
+        const hunksRaw = parseHunks(fileDiff).map(normalizeHunkBody);
+        const hunks = hunksRaw.filter((h4) => {
+          if (h4.lines.length === 0) return false;
+          let ctx = 0, rm32 = 0, add = 0;
+          for (const ln10 of h4.lines) {
+            if (ln10.type === "context") ctx++;
+            else if (ln10.type === "remove") rm32++;
+            else if (ln10.type === "add") add++;
+          }
+          return ctx + rm32 === h4.oldCount && ctx + add === h4.newCount;
+        });
+        if (hunks.length === 0) {
+          if (hunksRaw.length > 0) unlocatableFiles.push(file4);
+          continue;
+        }
+        const currentGen = await getCurrentGenContent(file4);
+        const workingTree = await getWorkingTreeContent(file4);
+        const isPureNewFile = hunks.every((h4) => h4.oldCount === 0);
+        const isPureDelete = hunks.every((h4) => h4.newCount === 0);
+        if (currentGen == null) {
+          if (!isPureNewFile) {
+            unlocatableFiles.push(file4);
+            continue;
+          }
+          if (workingTree == null) continue;
+          fragments.push(synthesizeNewFileDiff(file4, workingTree));
+          continue;
+        }
+        if (isPureNewFile) {
+          if (workingTree == null) {
+            fragments.push(synthesizeDeleteFileDiff(file4, currentGen));
+            continue;
+          }
+          if (workingTree === currentGen) {
+            continue;
+          }
+          const fullDiff = await unifiedDiff(currentGen, workingTree, file4);
+          if (fullDiff && fullDiff.trim()) fragments.push(fullDiff);
+          continue;
+        }
+        if (workingTree == null) {
+          if (!isPureDelete) {
+            unlocatableFiles.push(file4);
+            continue;
+          }
+          fragments.push(synthesizeDeleteFileDiff(file4, 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(file4);
+          continue;
+        }
+        const locInCurrentGen = locInCurrentGenRaw.map(
+          (l9) => resolveSpan(l9, currentGenLines, "old")
+        );
+        const locInWorkingTree = locInWorkingTreeRaw.map(
+          (l9) => resolveSpan(l9, workingTreeLines, "new")
+        );
+        const overlay = overlayRegions(
+          currentGenLines,
+          locInCurrentGen,
+          workingTreeLines,
+          locInWorkingTree
+        );
+        if (overlay === null) {
+          unlocatableFiles.push(file4);
+          continue;
+        }
+        if (overlay === currentGen) {
+          continue;
+        }
+        const fileUnifiedDiff = await unifiedDiff(currentGen, overlay, file4);
+        if (fileUnifiedDiff && fileUnifiedDiff.trim()) {
+          fragments.push(fileUnifiedDiff);
+        }
+      }
+      return {
+        diff: fragments.join(""),
+        unlocatableFiles
+      };
+    }
+    async function computePerPatchDiffWithFallback(patch5, getCurrentGenContent, getWorkingTreeContent, runCumulativeDiff) {
+      const ppDiff = await computePerPatchDiff(
+        patch5,
+        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(content5) {
+      return content5.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, offset2) {
+      if (offset2 + needle.length > haystack.length) return false;
+      for (let i9 = 0; i9 < needle.length; i9++) {
+        if (haystack[offset2 + i9] !== needle[i9]) return false;
+      }
+      return true;
+    }
+    function overlayRegions(currentGenLines, locInCurrentGen, workingTreeLines, locInWorkingTree) {
+      if (locInCurrentGen.length !== locInWorkingTree.length) {
+        return null;
+      }
+      const out = [];
+      let cursor = 0;
+      for (let i9 = 0; i9 < locInCurrentGen.length; i9++) {
+        const cg = locInCurrentGen[i9];
+        const wt10 = locInWorkingTree[i9];
+        if (cg.oursOffset > cursor) {
+          out.push(...currentGenLines.slice(cursor, cg.oursOffset));
+        }
+        out.push(...workingTreeLines.slice(wt10.oursOffset, wt10.oursOffset + wt10.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 tmp18 = await (0, import_promises210.mkdtemp)((0, import_node_path310.join)((0, import_node_os22.tmpdir)(), "fern-replay-pp-"));
+      try {
+        const beforePath = (0, import_node_path310.join)(tmp18, "before");
+        const afterPath = (0, import_node_path310.join)(tmp18, "after");
+        await (0, import_promises210.writeFile)(beforePath, beforeContent, "utf-8");
+        await (0, import_promises210.writeFile)(afterPath, afterContent, "utf-8");
+        const raw = await runGitDiffNoIndex(beforePath, afterPath);
+        if (!raw.trim()) return "";
+        return rewriteDiffHeaders(raw, filePath);
+      } finally {
+        await (0, import_promises210.rm)(tmp18, { recursive: true, force: true });
+      }
+    }
+    function runGitDiffNoIndex(beforePath, afterPath) {
+      return new Promise((resolve22, reject) => {
+        const proc2 = (0, import_node_child_process7.spawn)("git", ["diff", "--no-index", "--", beforePath, afterPath]);
+        let stdout = "";
+        let stderr = "";
+        proc2.stdout.on("data", (d5) => stdout += d5.toString());
+        proc2.stderr.on("data", (d5) => stderr += d5.toString());
+        proc2.on("close", (code5) => {
+          if (code5 === 0 || code5 === 1) resolve22(stdout);
+          else reject(new Error(`git diff --no-index failed (code ${code5}): ${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(file4, content5) {
+      const lines = content5.split("\n");
+      const hasTrailingNewline = content5.endsWith("\n");
+      const bodyLines = hasTrailingNewline ? lines.slice(0, -1) : lines;
+      const header = [
+        `diff --git a/${file4} b/${file4}`,
+        "new file mode 100644",
+        "--- /dev/null",
+        `+++ b/${file4}`,
+        `@@ -0,0 +1,${bodyLines.length} @@`
+      ].join("\n");
+      const body = bodyLines.map((l9) => `+${l9}`).join("\n");
+      const trailer = hasTrailingNewline ? "" : "\n\";
+      return header + "\n" + body + trailer + "\n";
+    }
+    function synthesizeDeleteFileDiff(file4, content5) {
+      const lines = content5.split("\n");
+      const hasTrailingNewline = content5.endsWith("\n");
+      const bodyLines = hasTrailingNewline ? lines.slice(0, -1) : lines;
+      const header = [
+        `diff --git a/${file4} b/${file4}`,
+        "deleted file mode 100644",
+        `--- a/${file4}`,
+        "+++ /dev/null",
+        `@@ -1,${bodyLines.length} +0,0 @@`
+      ].join("\n");
+      const body = bodyLines.map((l9) => `-${l9}`).join("\n");
+      const trailer = hasTrailingNewline ? "" : "\n\";
+      return header + "\n" + body + trailer + "\n";
+    }
     var ReplayService = class {
       git;
       detector;
@@ -342932,6 +343369,7 @@ CLI Version: ${options2.cliVersion}`;
         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") {
@@ -342950,7 +343388,8 @@ CLI Version: ${options2.cliVersion}`;
         if (newPatches.length > 0) {
           if (!options2?.stageOnly) {
             const appliedCount = results.filter((r5) => r5.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();
           }
@@ -343013,12 +343452,21 @@ CLI Version: ${options2.cliVersion}`;
           (p14) => preRebasePatchIds.has(p14.id) && !postRebasePatchIds.has(p14.id)
         );
         existingPatches = this.lockManager.getPatches();
-        const seenHashes = /* @__PURE__ */ new Set();
+        const seenHashes = /* @__PURE__ */ new Map();
         for (const p14 of existingPatches) {
-          if (seenHashes.has(p14.content_hash)) {
-            this.lockManager.removePatch(p14.id);
+          const priorOrigin = seenHashes.get(p14.content_hash);
+          if (priorOrigin !== void 0) {
+            const provenanceMissing = !priorOrigin || !p14.original_commit;
+            const sameOrigin = priorOrigin === p14.original_commit;
+            if (sameOrigin && !provenanceMissing) {
+              this.lockManager.removePatch(p14.id);
+            } else {
+              this.warnings.push(
+                `Preserving patch ${p14.id} (commit ${(p14.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(p14.content_hash);
+            seenHashes.set(p14.content_hash, p14.original_commit);
           }
         }
         existingPatches = this.lockManager.getPatches();
@@ -343079,6 +343527,7 @@ CLI Version: ${options2.cliVersion}`;
         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") {
@@ -343106,7 +343555,8 @@ CLI Version: ${options2.cliVersion}`;
           await this.committer.stageAll();
         } else {
           const appliedCount = results.filter((r5) => r5.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(
@@ -343130,7 +343580,7 @@ CLI Version: ${options2.cliVersion}`;
         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) {
@@ -343144,6 +343594,23 @@ CLI Version: ${options2.cliVersion}`;
             }
           }
         }
+        const conflictedFilePaths = /* @__PURE__ */ new Set();
+        for (const r5 of results) {
+          if (r5.status !== "conflict") continue;
+          if (r5.fileResults) {
+            for (const fr9 of r5.fileResults) {
+              if (fr9.status !== "conflict") continue;
+              conflictedFilePaths.add(fr9.file);
+              if (r5.resolvedFiles) {
+                for (const [orig, resolved] of Object.entries(r5.resolvedFiles)) {
+                  if (resolved === fr9.file) conflictedFilePaths.add(orig);
+                }
+              }
+            }
+          } else {
+            for (const f5 of r5.patch.files) conflictedFilePaths.add(f5);
+          }
+        }
         for (const result of results) {
           if (result.status === "conflict" && result.fileResults) {
             await this.trimAbsorbedFiles(result, currentGenSha);
@@ -343211,6 +343678,18 @@ CLI Version: ${options2.cliVersion}`;
                 keptAsUserOwned++;
                 continue;
               }
+              const overlapsConflicted = patch5.files.some((f5) => conflictedFilePaths.has(f5));
+              if (overlapsConflicted) {
+                patch5.status = "unresolved";
+                try {
+                  this.lockManager.updatePatch(patch5.id, { status: "unresolved" });
+                } catch {
+                }
+                this.warnings.push(
+                  `Patch ${patch5.id} (${patch5.original_message}) was preserved as unresolved because an earlier patch conflicted on the same file(s) (${patch5.files.join(", ")}). Run \`fern replay resolve\` to apply this customization manually.`
+                );
+                continue;
+              }
               this.lockManager.removePatch(patch5.id);
               absorbedPatchIds.add(patch5.id);
               absorbed++;
@@ -343226,13 +343705,22 @@ CLI Version: ${options2.cliVersion}`;
               continue;
             }
             const newContentHash = this.detector.computeContentHash(diff2);
-            if (seenContentHashes.has(newContentHash)) {
-              this.lockManager.removePatch(patch5.id);
-              absorbedPatchIds.add(patch5.id);
-              absorbed++;
-              continue;
+            const priorOrigin = seenContentHashes.get(newContentHash);
+            if (priorOrigin !== void 0) {
+              const provenanceMissing = !priorOrigin || !patch5.original_commit;
+              const sameOrigin = priorOrigin === patch5.original_commit;
+              if (sameOrigin && !provenanceMissing) {
+                this.lockManager.removePatch(patch5.id);
+                absorbedPatchIds.add(patch5.id);
+                absorbed++;
+                continue;
+              }
+              this.warnings.push(
+                `Preserving patch ${patch5.id} (commit ${(patch5.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, patch5.original_commit);
             }
-            seenContentHashes.add(newContentHash);
             patch5.base_generation = currentGenSha;
             patch5.patch_content = diff2;
             patch5.content_hash = newContentHash;
@@ -343408,8 +343896,14 @@ CLI Version: ${options2.cliVersion}`;
           }
           if (patch5.base_generation === currentGen) {
             try {
-              const diff2 = await this.git.exec(["diff", currentGen, "HEAD", "--", ...patch5.files]).catch(() => null);
-              if (diff2 === null) continue;
+              const ppResult = await computePerPatchDiffWithFallback(
+                patch5,
+                (f5) => this.git.showFile(currentGen, f5),
+                (f5) => this.git.showFile("HEAD", f5),
+                (files) => this.git.exec(["diff", currentGen, "HEAD", "--", ...files]).catch(() => null)
+              );
+              if (ppResult === null) continue;
+              const diff2 = ppResult.diff;
               if (!diff2.trim()) {
                 if (await allPatchFilesUserOwned(patch5)) continue;
                 this.lockManager.removePatch(patch5.id);
@@ -343451,8 +343945,14 @@ CLI Version: ${options2.cliVersion}`;
           try {
             const markerFiles = await this.git.exec(["grep", "-l", "<<<<<<< Generated", "HEAD", "--", ...patch5.files]).catch(() => "");
             if (markerFiles.trim()) continue;
-            const diff2 = await this.git.exec(["diff", currentGen, "HEAD", "--", ...patch5.files]).catch(() => null);
-            if (diff2 === null) continue;
+            const ppResult = await computePerPatchDiffWithFallback(
+              patch5,
+              (f5) => this.git.showFile(currentGen, f5),
+              (f5) => this.git.showFile("HEAD", f5),
+              (files) => this.git.exec(["diff", currentGen, "HEAD", "--", ...files]).catch(() => null)
+            );
+            if (ppResult === null) continue;
+            const diff2 = ppResult.diff;
             if (!diff2.trim()) {
               if (await allPatchFilesUserOwned(patch5)) {
                 try {
@@ -343477,6 +343977,32 @@ CLI Version: ${options2.cliVersion}`;
         }
         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 fr9 of result.fileResults) {
+            const dropped = fr9.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(
+              `${fr9.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.
@@ -343486,7 +344012,7 @@ CLI Version: ${options2.cliVersion}`;
           if (result.status !== "conflict" || !result.fileResults) continue;
           for (const fileResult of result.fileResults) {
             if (fileResult.status !== "conflict") continue;
-            const filePath = (0, import_node_path310.join)(this.outputDir, fileResult.file);
+            const filePath = (0, import_node_path43.join)(this.outputDir, fileResult.file);
             try {
               const content5 = (0, import_node_fs210.readFileSync)(filePath, "utf-8");
               const stripped = stripConflictMarkers(content5);
@@ -343516,7 +344042,7 @@ CLI Version: ${options2.cliVersion}`;
         }
       }
       readFernignorePatterns() {
-        const fernignorePath = (0, import_node_path310.join)(this.outputDir, ".fernignore");
+        const fernignorePath = (0, import_node_path43.join)(this.outputDir, ".fernignore");
         if (!(0, import_node_fs210.existsSync)(fernignorePath)) return [];
         return (0, import_node_fs210.readFileSync)(fernignorePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
       }
@@ -343534,6 +344060,9 @@ CLI Version: ${options2.cliVersion}`;
           };
         }).filter((d5) => d5.files.length > 0);
         const partialCount = conflictDetails.filter((d5) => d5.cleanFiles && d5.cleanFiles.length > 0).length;
+        const unresolvedResults = results.filter(
+          (r5) => r5.status === "conflict" || r5.patch.status === "unresolved"
+        );
         return {
           flow: flow4,
           patchesDetected: patches.length,
@@ -343550,7 +344079,7 @@ CLI Version: ${options2.cliVersion}`;
           patchesRefreshed: preRebaseCounts && preRebaseCounts.contentRefreshed > 0 ? preRebaseCounts.contentRefreshed : void 0,
           conflicts: conflictResults.flatMap((r5) => r5.fileResults?.filter((f5) => f5.status === "conflict") ?? []),
           conflictDetails: conflictDetails.length > 0 ? conflictDetails : void 0,
-          unresolvedPatches: conflictResults.length > 0 ? conflictResults.map((r5) => ({
+          unresolvedPatches: unresolvedResults.length > 0 ? unresolvedResults.map((r5) => ({
             patchId: r5.patch.id,
             patchMessage: r5.patch.original_message,
             files: r5.patch.files,
@@ -343561,9 +344090,36 @@ CLI Version: ${options2.cliVersion}`;
         };
       }
     };
+    function computeCommitBuckets(results, absorbedPatchIds, patchesPassedToCommit) {
+      const resultByPatchId = /* @__PURE__ */ new Map();
+      for (const r5 of results) resultByPatchId.set(r5.patch.id, r5);
+      const applied = [];
+      const unresolved = [];
+      const absorbed = [];
+      for (const patch5 of patchesPassedToCommit) {
+        if (absorbedPatchIds.has(patch5.id)) {
+          absorbed.push(patch5);
+          continue;
+        }
+        const r5 = resultByPatchId.get(patch5.id);
+        if (!r5) {
+          applied.push(patch5);
+          continue;
+        }
+        if (r5.status === "conflict" || patch5.status === "unresolved") {
+          unresolved.push(patch5);
+          continue;
+        }
+        if (r5.status === "applied") {
+          applied.push(patch5);
+          continue;
+        }
+      }
+      return { applied, unresolved, absorbed };
+    }
     var import_node_crypto22 = require("crypto");
     var import_node_fs33 = require("fs");
-    var import_node_path43 = require("path");
+    var import_node_path52 = require("path");
     var import_minimatch32 = require_commonjs3();
     var import_yaml22 = require_dist9();
     var FernignoreMigrator = class {
@@ -343576,10 +344132,10 @@ CLI Version: ${options2.cliVersion}`;
         this.outputDir = outputDir;
       }
       fernignoreExists() {
-        return (0, import_node_fs33.existsSync)((0, import_node_path43.join)(this.outputDir, ".fernignore"));
+        return (0, import_node_fs33.existsSync)((0, import_node_path52.join)(this.outputDir, ".fernignore"));
       }
       readFernignorePatterns() {
-        const fernignorePath = (0, import_node_path43.join)(this.outputDir, ".fernignore");
+        const fernignorePath = (0, import_node_path52.join)(this.outputDir, ".fernignore");
         if (!(0, import_node_fs33.existsSync)(fernignorePath)) {
           return [];
         }
@@ -343639,7 +344195,16 @@ CLI Version: ${options2.cliVersion}`;
                 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,
@@ -343672,7 +344237,7 @@ CLI Version: ${options2.cliVersion}`;
         return results;
       }
       readFileContent(filePath) {
-        const fullPath = (0, import_node_path43.join)(this.outputDir, filePath);
+        const fullPath = (0, import_node_path52.join)(this.outputDir, filePath);
         if (!(0, import_node_fs33.existsSync)(fullPath)) {
           return null;
         }
@@ -343737,7 +344302,7 @@ CLI Version: ${options2.cliVersion}`;
         };
       }
       movePatternsToReplayYml(patterns) {
-        const replayYmlPath = (0, import_node_path43.join)(this.outputDir, ".fern", "replay.yml");
+        const replayYmlPath = (0, import_node_path52.join)(this.outputDir, ".fern", "replay.yml");
         let config5 = {};
         if ((0, import_node_fs33.existsSync)(replayYmlPath)) {
           const content5 = (0, import_node_fs33.readFileSync)(replayYmlPath, "utf-8");
@@ -343746,7 +344311,7 @@ CLI Version: ${options2.cliVersion}`;
         const existing = config5.exclude ?? [];
         const merged = [.../* @__PURE__ */ new Set([...existing, ...patterns])];
         config5.exclude = merged;
-        const dir = (0, import_node_path43.dirname)(replayYmlPath);
+        const dir = (0, import_node_path52.dirname)(replayYmlPath);
         if (!(0, import_node_fs33.existsSync)(dir)) {
           (0, import_node_fs33.mkdirSync)(dir, { recursive: true });
         }
@@ -343755,7 +344320,7 @@ CLI Version: ${options2.cliVersion}`;
     };
     var import_node_crypto32 = require("crypto");
     var import_node_fs42 = require("fs");
-    var import_node_path52 = require("path");
+    var import_node_path62 = require("path");
     init_GitClient();
     async function bootstrap(outputDir, options2) {
       const git = new GitClient(outputDir);
@@ -343922,7 +344487,7 @@ CLI Version: ${options2.cliVersion}`;
     }
     var REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml", ".gitattributes"];
     function ensureFernignoreEntries(outputDir) {
-      const fernignorePath = (0, import_node_path52.join)(outputDir, ".fernignore");
+      const fernignorePath = (0, import_node_path62.join)(outputDir, ".fernignore");
       let content5 = "";
       if ((0, import_node_fs42.existsSync)(fernignorePath)) {
         content5 = (0, import_node_fs42.readFileSync)(fernignorePath, "utf-8");
@@ -343946,7 +344511,7 @@ CLI Version: ${options2.cliVersion}`;
     }
     var GITATTRIBUTES_ENTRIES = [".fern/replay.lock linguist-generated=true"];
     function ensureGitattributesEntries(outputDir) {
-      const gitattributesPath = (0, import_node_path52.join)(outputDir, ".gitattributes");
+      const gitattributesPath = (0, import_node_path62.join)(outputDir, ".gitattributes");
       let content5 = "";
       if ((0, import_node_fs42.existsSync)(gitattributesPath)) {
         content5 = (0, import_node_fs42.readFileSync)(gitattributesPath, "utf-8");
@@ -344138,6 +344703,8 @@ CLI Version: ${options2.cliVersion}`;
         nothingToReset: false
       };
     }
+    var import_promises310 = require("fs/promises");
+    var import_node_path72 = require("path");
     init_GitClient();
     async function resolve15(outputDir, options2) {
       const lockManager = new LockfileManager(outputDir);
@@ -344153,7 +344720,7 @@ CLI Version: ${options2.cliVersion}`;
       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 patch5 of unresolvedPatches) {
@@ -344179,20 +344746,38 @@ CLI Version: ${options2.cliVersion}`;
       if (patchesToCommit.length > 0) {
         const currentGen = lock.current_generation;
         const detector = new ReplayDetector(git, lockManager, outputDir);
+        const warnings = [];
         let patchesResolved = 0;
         for (const patch5 of patchesToCommit) {
-          const diff2 = await git.exec(["diff", currentGen, "--", ...patch5.files]).catch(() => null);
-          if (!diff2 || !diff2.trim()) {
+          const result = await computePerPatchDiffWithFallback(
+            patch5,
+            (f5) => git.showFile(currentGen, f5),
+            (f5) => (0, import_promises310.readFile)((0, import_node_path72.join)(outputDir, f5), "utf-8").catch(() => null),
+            (files) => git.exec(["diff", currentGen, "--", ...files]).catch(() => null)
+          );
+          if (result === null) {
+            warnings.push(
+              `Patch ${patch5.id}: cumulative-diff fallback failed for unlocatable files; preserving patch unchanged`
+            );
+            continue;
+          }
+          const diff2 = result.diff;
+          if (!diff2.trim()) {
             lockManager.removePatch(patch5.id);
             continue;
           }
+          if (result.hadFallback) {
+            warnings.push(
+              `Patch ${patch5.id}: ${result.fallbackFiles.join(", ")} could not be anchored; cumulative-diff fallback applied for those files`
+            );
+          }
           const newContentHash = detector.computeContentHash(diff2);
-          const changedFiles = await getChangedFiles(git, currentGen, patch5.files);
+          const changedFiles = result.hadFallback ? await getChangedFiles(git, currentGen, patch5.files) : extractFilesFromDiff(diff2);
           lockManager.markPatchResolved(patch5.id, {
             patch_content: diff2,
             content_hash: newContentHash,
             base_generation: currentGen,
-            files: changedFiles
+            files: changedFiles.length > 0 ? changedFiles : patch5.files
           });
           patchesResolved++;
         }
@@ -344208,7 +344793,8 @@ CLI Version: ${options2.cliVersion}`;
           success: true,
           commitSha: commitSha2,
           phase: "committed",
-          patchesResolved
+          patchesResolved,
+          warnings: warnings.length > 0 ? warnings : void 0
         };
       }
       const committer = new ReplayCommitter(git, outputDir);
@@ -344226,6 +344812,24 @@ CLI Version: ${options2.cliVersion}`;
       const changed = filesOutput.trim().split("\n").filter(Boolean).filter((f5) => !f5.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);
+    }
     function status(outputDir) {
       const lockManager = new LockfileManager(outputDir);
       if (!lockManager.exists()) {
@@ -621386,7 +621990,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "5.0.0-6-gb0a2ec4ace2",
+          version: "5.1.0",
           usingAccessToken: true
         }
       });
@@ -621440,7 +622044,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "5.0.0-6-gb0a2ec4ace2",
+        version: "5.1.0",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -625100,6 +625704,133 @@ var TelemetryClient = class _TelemetryClient {
   }
 };
 
+// ../cli-v2/lib/ui/TtyAwareLogger.js
+var import_is_ci3 = __toESM(require_is_ci(), 1);
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var SPINNER_INTERVAL_MS = 100;
+var TtyAwareLogger2 = class {
+  isTTY;
+  stdout;
+  stderr;
+  paintables = [];
+  lastPaint = "";
+  frameIndex = 0;
+  interval;
+  suspended = false;
+  suspendBuffer = [];
+  finished = false;
+  constructor(stdout, stderr) {
+    this.stdout = stdout;
+    this.stderr = stderr;
+    this.isTTY = stdout.isTTY === true && !import_is_ci3.default;
+  }
+  /**
+   * Register a paintable. The first registration starts the repaint loop.
+   */
+  register(paintable) {
+    this.paintables.push(paintable);
+    if (this.isTTY && this.interval == null) {
+      this.stdout.write(ansi_escapes_default.cursorHide);
+      this.repaint();
+      this.interval = setInterval(() => this.repaint(), SPINNER_INTERVAL_MS);
+    }
+  }
+  /**
+   * Write content above the paint region.
+   *
+   * On non-TTY streams the content is written verbatim. On TTY streams the
+   * paint region is cleared, the content is written, and the paint region
+   * is redrawn in place.
+   */
+  write(content5, { stderr = false } = {}) {
+    const stream5 = stderr ? this.stderr : this.stdout;
+    if (!this.isTTY) {
+      stream5.write(content5);
+      return;
+    }
+    if (this.suspended) {
+      this.suspendBuffer.push({ content: content5, stderr });
+      return;
+    }
+    this.stdout.write(this.clear());
+    stream5.write(content5);
+    this.stdout.write(this.paint());
+  }
+  /**
+   * Pause the paint loop while `run` executes, buffering any `write()` calls,
+   * then flush the buffer and resume. Useful for writing content that must
+   * not be clobbered by a repaint (e.g. an inquirer prompt).
+   */
+  async takeOverTerminal(run) {
+    if (!this.isTTY) {
+      await run();
+      return;
+    }
+    this.stopLoop();
+    this.stdout.write(this.clear());
+    this.suspended = true;
+    try {
+      await run();
+    } finally {
+      this.suspended = false;
+      for (const { content: content5, stderr: isStderr } of this.suspendBuffer) {
+        const stream5 = isStderr ? this.stderr : this.stdout;
+        stream5.write(content5);
+      }
+      this.suspendBuffer = [];
+      if (this.paintables.length > 0) {
+        this.stdout.write(ansi_escapes_default.cursorHide);
+        this.repaint();
+        this.interval = setInterval(() => this.repaint(), SPINNER_INTERVAL_MS);
+      }
+    }
+  }
+  /**
+   * Stop the paint loop, perform one final repaint, and restore the cursor.
+   * Idempotent.
+   */
+  finish() {
+    if (!this.isTTY || this.finished) {
+      return;
+    }
+    this.finished = true;
+    this.stopLoop();
+    this.stdout.write(this.clear() + this.paint());
+    this.stdout.write(ansi_escapes_default.cursorShow);
+  }
+  stopLoop() {
+    if (this.interval != null) {
+      clearInterval(this.interval);
+      this.interval = void 0;
+    }
+  }
+  repaint() {
+    this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES.length;
+    this.stdout.write(this.clear() + this.paint());
+  }
+  clear() {
+    if (this.lastPaint.length === 0) {
+      return "";
+    }
+    return ansi_escapes_default.eraseLines(this.lastPaint.split("\n").length);
+  }
+  paint() {
+    if (this.paintables.length === 0) {
+      this.lastPaint = "";
+      return "";
+    }
+    const spinnerFrame = SPINNER_FRAMES[this.frameIndex] ?? SPINNER_FRAMES[0];
+    const bodies = this.paintables.map((p14) => p14.paint(spinnerFrame)).filter((body) => body.length > 0);
+    if (bodies.length === 0) {
+      this.lastPaint = "";
+      return "";
+    }
+    const paint = bodies.join("\n") + "\n";
+    this.lastPaint = paint;
+    return paint;
+  }
+};
+
 // ../cli-v2/lib/api/config/converter/ApiDefinitionConverter.js
 init_lib6();
 var DEFAULT_API_NAME = "api";
@@ -626002,7 +626733,7 @@ var Context = class _Context {
   tokenService;
   ttyAwareLogger;
   static async create({ stdout, stderr, cwd: cwd2, logLevel }) {
-    const ttyAwareLogger = new TtyAwareLogger(stdout, stderr);
+    const ttyAwareLogger = new TtyAwareLogger2(stdout, stderr);
     const telemetry = await TelemetryClient.create({ isTTY: ttyAwareLogger.isTTY });
     return new _Context({ stdout, stderr, cwd: cwd2, logLevel, ttyAwareLogger, telemetry });
   }
@@ -626245,31 +626976,44 @@ ${source_default.dim(`Logs written to: ${this.logs.absoluteFilePath}`)}
     this.ttyAwareLogger.finish();
   }
   log(level, ...parts) {
-    this.logImmediately([
-      {
-        parts,
-        level,
-        time: /* @__PURE__ */ new Date()
-      }
-    ]);
+    this.writeLog(level, parts, { stderr: false });
   }
   logStderr(level, ...parts) {
-    this.logImmediately([
-      {
-        parts,
-        level,
-        time: /* @__PURE__ */ new Date()
-      }
-    ], { stderr: true });
+    this.writeLog(level, parts, { stderr: true });
   }
-  logImmediately(logs4, { stderr = false } = {}) {
-    const filtered = logs4.filter((log4) => LOG_LEVELS.indexOf(log4.level) >= LOG_LEVELS.indexOf(this.logLevel));
-    this.ttyAwareLogger.log(filtered, {
-      includeDebugInfo: this.logLevel === LogLevel.Debug,
-      stderr
+  writeLog(level, parts, { stderr }) {
+    if (LOG_LEVELS.indexOf(level) < LOG_LEVELS.indexOf(this.logLevel)) {
+      return;
+    }
+    const content5 = formatLogContent({
+      level,
+      parts,
+      includeDebugInfo: this.logLevel === LogLevel.Debug
     });
+    this.ttyAwareLogger.write(content5, { stderr });
   }
 };
+function formatLogContent({ level, parts, includeDebugInfo }) {
+  let content5 = parts.join(" ");
+  if (includeDebugInfo) {
+    content5 = `${source_default.dim(`${getLogLevelPrefix(level)} ${(/* @__PURE__ */ new Date()).toISOString()} `)}${content5}`;
+  }
+  content5 += "\n";
+  switch (level) {
+    case LogLevel.Error:
+      return source_default.red(content5);
+    case LogLevel.Warn:
+      return source_default.hex("FFA500")(content5);
+    case LogLevel.Trace:
+    case LogLevel.Debug:
+    case LogLevel.Info:
+      return content5;
+  }
+}
+var LOG_LEVEL_PREFIX_WIDTH = Math.max(...LOG_LEVELS.map((l9) => l9.length));
+function getLogLevelPrefix(level) {
+  return level.toUpperCase().padEnd(LOG_LEVEL_PREFIX_WIDTH);
+}
 
 // ../cli-v2/lib/context/loadDotenvFile.js
 var import_dotenv = __toESM(require_main2(), 1);
@@ -833175,7 +833919,7 @@ var LOCAL_STORAGE_FOLDER4 = ".fern-dev";
 var LOGS_FOLDER_NAME = "logs";
 var MAX_LOGS_DIR_SIZE_BYTES = 100 * 1024 * 1024;
 function getCliSource() {
-  const version7 = "5.0.0-6-gb0a2ec4ace2";
+  const version7 = "5.1.0";
   return `cli@${version7}`;
 }
 var DebugLogger = class {
@@ -845593,7 +846337,7 @@ var LegacyDocsPublisher = class {
         previewId,
         disableTemplates: void 0,
         skipUpload,
-        cliVersion: "5.0.0-6-gb0a2ec4ace2",
+        cliVersion: "5.1.0",
         loginCommand: "fern auth login"
       });
       if (taskContext.getResult() === TaskResult.Failure) {
@@ -845733,15 +846477,19 @@ var TaskGroup = class _TaskGroup {
   /**
    * Called by TtyAwareLogger to get the current display.
    * This is the integration point with TtyAwareLogger.
+   *
+   * Renders the task list wrapped in a bordered frame so multiple concurrent
+   * TaskGroups (e.g. one per API in a fan-out) read as separate boxes rather
+   * than a single megaframe.
    */
-  printInteractiveTasks({ spinner }) {
+  paint(spinnerFrame) {
     const lines = [];
     for (const id2 of this.taskOrder) {
       const task = this.tasks[id2];
       if (task == null) {
         continue;
       }
-      const line = this.formatTaskLine(task, spinner);
+      const line = this.formatTaskLine(task, spinnerFrame);
       if (line != null) {
         lines.push(line);
       }
@@ -845749,7 +846497,8 @@ var TaskGroup = class _TaskGroup {
     if (lines.length === 0) {
       return "";
     }
-    return lines.join("\n");
+    const body = lines.join("\n");
+    return ["\u250C\u2500", addPrefixToString({ content: body, prefix: "\u2502 ", includePrefixOnAllLines: true }), "\u2514\u2500"].join("\n");
   }
   /**
    * Complete the task group and show summary.
@@ -845842,7 +846591,7 @@ var TaskGroup = class _TaskGroup {
     }
     const lines = [];
     for (const stage of stages) {
-      const icon = this.getStageIcon(stage.status, spinnerFrame);
+      const icon = this.getStageIcon(stage.status);
       let line = `
     ${icon} ${this.getStageLabel(stage)}`;
       if (stage.detail != null) {
@@ -845873,7 +846622,7 @@ var TaskGroup = class _TaskGroup {
    * Uses a static arrow (▸) for running stages to avoid visual noise
    * from having multiple spinners (the parent task already has a spinner).
    */
-  getStageIcon(status, _spinnerFrame) {
+  getStageIcon(status) {
     switch (status) {
       case "pending":
         return source_default.dim("\u25CB");
@@ -846002,7 +846751,7 @@ ${indentStr}${source_default.dim(`... ${hiddenCount} earlier logs hidden ...`)}$
       return;
     }
     this.isRegistered = true;
-    this.context.ttyAwareLogger.registerTask(this);
+    this.context.ttyAwareLogger.register(this);
   }
 };
 
@@ -919915,7 +920664,7 @@ var CliContext = class _CliContext {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "5.0.0-6-gb0a2ec4ace2";
+    return "5.1.0";
   }
   getCliName() {
     if (false) {
@@ -938746,7 +939495,7 @@ init_lib6();
 var import_cli_progress2 = __toESM(require_cli_progress(), 1);
 var import_fs42 = require("fs");
 var import_promises191 = require("fs/promises");
-var import_is_ci3 = __toESM(require_is_ci(), 1);
+var import_is_ci4 = __toESM(require_is_ci(), 1);
 var import_path105 = __toESM(require("path"), 1);
 
 // src/commands/write-translation/translation-service.ts
@@ -939603,7 +940352,7 @@ async function writeTranslationForProject({
       }
       const totalFilesToProcess = filesToProcess.length + (docsConfigHasChanged ? 1 : 0);
       const totalProgressItems = totalFilesToProcess * targetLanguages.length;
-      const useProgressBar = process.stdout.isTTY && !import_is_ci3.default && totalProgressItems > 0;
+      const useProgressBar = process.stdout.isTTY && !import_is_ci4.default && totalProgressItems > 0;
       let progressBar;
       if (useProgressBar) {
         progressBar = new import_cli_progress2.default.SingleBar({