@fern-api/fern-api-dev 4.109.0 → 5.0.0-10-g2ffb11338db

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()) {
@@ -510619,7 +511223,7 @@ var MetadataConfig = external_exports.object({
   "twitter:url": external_exports.string().optional(),
   "twitter:card": TwitterCardSetting.optional(),
   "og:dynamic": external_exports.boolean().optional(),
-  "og:background-image": external_exports.string().optional(),
+  "og:dynamic:background-image": external_exports.string().optional(),
   "og:dynamic:text-color": external_exports.string().optional(),
   "og:dynamic:background-color": external_exports.string().optional(),
   "og:dynamic:logo-color": external_exports.enum(["dark", "light"]).optional(),
@@ -513961,7 +514565,7 @@ var MetadataConfig2 = schemas_exports6.object({
   twitterUrl: schemas_exports6.property("twitter:url", schemas_exports6.string().optional()),
   twitterCard: schemas_exports6.property("twitter:card", TwitterCardSetting3.optional()),
   ogDynamic: schemas_exports6.property("og:dynamic", schemas_exports6.boolean().optional()),
-  ogBackgroundImage: schemas_exports6.property("og:background-image", schemas_exports6.string().optional()),
+  ogDynamicBackgroundImage: schemas_exports6.property("og:dynamic:background-image", schemas_exports6.string().optional()),
   ogDynamicTextColor: schemas_exports6.property("og:dynamic:text-color", schemas_exports6.string().optional()),
   ogDynamicBackgroundColor: schemas_exports6.property("og:dynamic:background-color", schemas_exports6.string().optional()),
   ogDynamicLogoColor: schemas_exports6.property("og:dynamic:logo-color", OgDynamicLogoColor2.optional()),
@@ -543279,7 +543883,7 @@ async function convertMetadata(metadata, absoluteFilepathToDocsConfig, context3)
     "twitter:url": metadata.twitterUrl,
     "twitter:card": metadata.twitterCard,
     "og:dynamic": metadata.ogDynamic,
-    "og:background-image": await convertFilepathOrUrl(metadata.ogBackgroundImage, absoluteFilepathToDocsConfig),
+    "og:dynamic:background-image": await convertFilepathOrUrl(metadata.ogDynamicBackgroundImage, absoluteFilepathToDocsConfig),
     "og:dynamic:text-color": metadata.ogDynamicTextColor,
     "og:dynamic:background-color": metadata.ogDynamicBackgroundColor,
     "og:dynamic:logo-color": metadata.ogDynamicLogoColor,
@@ -543296,7 +543900,7 @@ async function convertMetadata(metadata, absoluteFilepathToDocsConfig, context3)
 function warnOnMetadataConflicts(metadata, context3) {
   const dynamicEnabled = metadata.ogDynamic === true;
   const dynamicSettings = [
-    ["og:background-image", metadata.ogBackgroundImage],
+    ["og:dynamic:background-image", metadata.ogDynamicBackgroundImage],
     ["og:dynamic:text-color", metadata.ogDynamicTextColor],
     ["og:dynamic:background-color", metadata.ogDynamicBackgroundColor],
     ["og:dynamic:logo-color", metadata.ogDynamicLogoColor],
@@ -621386,7 +621990,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "4.109.0",
+          version: "5.0.0-10-g2ffb11338db",
           usingAccessToken: true
         }
       });
@@ -621440,7 +622044,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "4.109.0",
+        version: "5.0.0-10-g2ffb11338db",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -798819,8 +799423,8 @@ async function collectFilesFromDocsConfig({ parsedDocsConfig }) {
   if (parsedDocsConfig.metadata?.["twitter:image"] != null && parsedDocsConfig.metadata["twitter:image"].type === "filepath") {
     filepaths.add(parsedDocsConfig.metadata["twitter:image"].value);
   }
-  if (parsedDocsConfig.metadata?.["og:background-image"] != null && parsedDocsConfig.metadata["og:background-image"].type === "filepath") {
-    filepaths.add(parsedDocsConfig.metadata["og:background-image"].value);
+  if (parsedDocsConfig.metadata?.["og:dynamic:background-image"] != null && parsedDocsConfig.metadata["og:dynamic:background-image"].type === "filepath") {
+    filepaths.add(parsedDocsConfig.metadata["og:dynamic:background-image"].value);
   }
   if (parsedDocsConfig.typography?.bodyFont != null) {
     parsedDocsConfig.typography.bodyFont.variants.forEach((variant) => {
@@ -800802,13 +801406,13 @@ https://buildwithfern.com/learn/docs/getting-started/project-structure#api-defin
     if (this.parsedDocsConfig.metadata == null) {
       return;
     }
-    const { "og:image": ogImage, "og:logo": ogLogo, "twitter:image": twitterImage, "og:background-image": ogBackgroundImage, ...rest } = this.parsedDocsConfig.metadata;
+    const { "og:image": ogImage, "og:logo": ogLogo, "twitter:image": twitterImage, "og:dynamic:background-image": ogDynamicBackgroundImage, ...rest } = this.parsedDocsConfig.metadata;
     return {
       ...rest,
       "og:image": this.convertFileIdOrUrl(ogImage),
       "og:logo": this.convertFileIdOrUrl(ogLogo),
       "twitter:image": this.convertFileIdOrUrl(twitterImage),
-      "og:background-image": this.convertFileIdOrUrl(ogBackgroundImage)
+      "og:dynamic:background-image": this.convertFileIdOrUrl(ogDynamicBackgroundImage)
     };
   }
   convertFileIdOrUrl(filepathOrUrl) {
@@ -800991,7 +801595,7 @@ async function resolveThemeFileUrls(themeConfig, tmpDir) {
   cfg.footer = await maybeDownload(cfg.footer);
   if (cfg.metadata != null && typeof cfg.metadata === "object") {
     const meta5 = cfg.metadata;
-    for (const imgKey of ["og:image", "twitter:image", "og:background-image", "og:logo"]) {
+    for (const imgKey of ["og:image", "twitter:image", "og:dynamic:background-image", "og:logo"]) {
       meta5[imgKey] = await maybeDownload(meta5[imgKey]);
     }
   }
@@ -833175,7 +833779,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 = "4.109.0";
+  const version7 = "5.0.0-10-g2ffb11338db";
   return `cli@${version7}`;
 }
 var DebugLogger = class {
@@ -841615,7 +842219,7 @@ var definitions6 = {
           }
         ]
       },
-      "og:background-image": {
+      "og:dynamic:background-image": {
         oneOf: [
           {
             type: "string"
@@ -845593,7 +846197,7 @@ var LegacyDocsPublisher = class {
         previewId,
         disableTemplates: void 0,
         skipUpload,
-        cliVersion: "4.109.0",
+        cliVersion: "5.0.0-10-g2ffb11338db",
         loginCommand: "fern auth login"
       });
       if (taskContext.getResult() === TaskResult.Failure) {
@@ -866286,6 +866890,15 @@ var DynamicLiteralMapper = class extends WithGeneration {
     }));
   }
   convertObject({ object_, value: value2, fallbackToDefault }) {
+    const classReference4 = this.csharp.classReference({
+      origin: object_.declaration,
+      namespace: this.context.getNamespace(object_.declaration.fernFilepath)
+    });
+    const propertyNameByWireValue = /* @__PURE__ */ new Map();
+    for (const property23 of object_.properties) {
+      const actualName = this.context.resolvePropertyName(classReference4, property23.name.name);
+      propertyNameByWireValue.set(property23.name.wireValue, actualName);
+    }
     const record22 = this.context.getRecord(value2) ?? {};
     const properties7 = this.context.associateByWireValue({
       parameters: object_.properties,
@@ -866295,7 +866908,7 @@ var DynamicLiteralMapper = class extends WithGeneration {
       this.context.errors.scope(property23.name.wireValue);
       try {
         return {
-          name: this.context.getClassName(property23.name.name),
+          name: propertyNameByWireValue.get(property23.name.wireValue) ?? this.context.getClassName(property23.name.name),
           value: this.convert(property23)
         };
       } finally {
@@ -866304,7 +866917,7 @@ var DynamicLiteralMapper = class extends WithGeneration {
     });
     const providedWireValues = new Set(Object.keys(record22));
     for (const property23 of object_.properties) {
-      const fieldName = this.context.getClassName(property23.name.name);
+      const fieldName = propertyNameByWireValue.get(property23.name.wireValue) ?? this.context.getClassName(property23.name.name);
       if (providedWireValues.has(property23.name.wireValue)) {
         if (this.isRequiredProperty(property23.typeReference)) {
           const existing = fields.find((f5) => f5.name === fieldName);
@@ -866328,10 +866941,7 @@ var DynamicLiteralMapper = class extends WithGeneration {
       }
     }
     return this.csharp.Literal.class_({
-      reference: this.csharp.classReference({
-        origin: object_.declaration,
-        namespace: this.context.getNamespace(object_.declaration.fernFilepath)
-      }),
+      reference: classReference4,
       fields
     });
   }
@@ -866382,13 +866992,17 @@ var DynamicLiteralMapper = class extends WithGeneration {
       return void 0;
     }
     visited.add(typeId);
+    const classReference4 = this.csharp.classReference({
+      origin: object_.declaration,
+      namespace: this.context.getNamespace(object_.declaration.fernFilepath)
+    });
     const fields = [];
     for (const property23 of object_.properties) {
       if (this.isRequiredProperty(property23.typeReference)) {
         const defaultValue = this.getDefaultLiteralForType(property23.typeReference, visited);
         if (defaultValue != null) {
           fields.push({
-            name: this.context.getClassName(property23.name.name),
+            name: this.context.resolvePropertyName(classReference4, property23.name.name),
             value: defaultValue
           });
         }
@@ -866396,10 +867010,7 @@ var DynamicLiteralMapper = class extends WithGeneration {
     }
     visited.delete(typeId);
     return this.csharp.Literal.class_({
-      reference: this.csharp.classReference({
-        origin: object_.declaration,
-        namespace: this.context.getNamespace(object_.declaration.fernFilepath)
-      }),
+      reference: classReference4,
       fields
     });
   }
@@ -866953,6 +867564,22 @@ var DynamicSnippetsGeneratorContext = class _DynamicSnippetsGeneratorContext ext
   getPropertyName(name2) {
     return name2.pascalCase.safeName;
   }
+  /**
+   * Returns a property name that is safe within the given class reference's scope.
+   * Detects collisions where PascalCase(property) == ClassName and returns the
+   * renamed identifier (e.g., "CatalogV1Id_") to avoid CS0542 / CS0117.
+   */
+  resolvePropertyName(classReference4, name2) {
+    const expectedName = name2.pascalCase.safeName;
+    const redirected = classReference4.scope.getRedirectedFieldName(expectedName);
+    if (redirected) {
+      return redirected;
+    }
+    if (classReference4.scope.isField(expectedName)) {
+      return expectedName;
+    }
+    return classReference4.registerField(expectedName);
+  }
   getMethodName(name2) {
     return `${name2.pascalCase.safeName}Async`;
   }
@@ -867439,13 +868066,17 @@ var EndpointSnippetGenerator2 = class extends WithGeneration {
     });
   }
   getInlinedRequestArg({ request: request7, snippet: snippet2, pathParameterFields, filePropertyInfo }) {
+    const classReference4 = this.csharp.classReference({
+      origin: request7.declaration,
+      namespace: this.context.getNamespace(request7.declaration.fernFilepath)
+    });
     this.context.errors.scope(Scope4.QueryParameters);
     const queryParameters = this.context.associateQueryParametersByWireValue({
       parameters: request7.queryParameters ?? [],
       values: snippet2.queryParameters ?? {}
     });
     const queryParameterFields = queryParameters.map((queryParameter) => ({
-      name: this.context.getPropertyName(queryParameter.name.name),
+      name: this.context.resolvePropertyName(classReference4, queryParameter.name.name),
       value: this.context.dynamicLiteralMapper.convert(queryParameter)
     }));
     this.context.errors.unscope();
@@ -867455,7 +868086,7 @@ var EndpointSnippetGenerator2 = class extends WithGeneration {
       values: snippet2.headers ?? {}
     });
     const headerFields = headers2.map((header) => ({
-      name: this.context.getPropertyName(header.name.name),
+      name: this.context.resolvePropertyName(classReference4, header.name.name),
       value: this.context.dynamicLiteralMapper.convert({
         ...header,
         fallbackToDefault: header.name.wireValue
@@ -867466,30 +868097,32 @@ var EndpointSnippetGenerator2 = class extends WithGeneration {
     const requestBodyFields = request7.body != null ? this.getInlinedRequestBodyConstructorFields({
       body: request7.body,
       value: snippet2.requestBody,
-      filePropertyInfo
+      filePropertyInfo,
+      classReference: classReference4
     }) : [];
     this.context.errors.unscope();
     return this.csharp.Literal.class_({
-      reference: this.csharp.classReference({
-        origin: request7.declaration,
-        namespace: this.context.getNamespace(request7.declaration.fernFilepath)
-      }),
+      reference: classReference4,
       fields: [...pathParameterFields, ...queryParameterFields, ...headerFields, ...requestBodyFields]
     });
   }
-  getInlinedRequestBodyConstructorFields({ body, value: value2, filePropertyInfo }) {
+  getInlinedRequestBodyConstructorFields({ body, value: value2, filePropertyInfo, classReference: classReference4 }) {
     switch (body.type) {
       case "properties":
-        return this.getInlinedRequestBodyPropertyConstructorFields({ parameters: body.value, value: value2 });
+        return this.getInlinedRequestBodyPropertyConstructorFields({
+          parameters: body.value,
+          value: value2,
+          classReference: classReference4
+        });
       case "referenced":
-        return [this.getReferencedRequestBodyPropertyConstructorField({ body, value: value2 })];
+        return [this.getReferencedRequestBodyPropertyConstructorField({ body, value: value2, classReference: classReference4 })];
       case "fileUpload":
         return this.getFileUploadRequestBodyConstructorFields({ filePropertyInfo });
       default:
         assertNever(body);
     }
   }
-  getInlinedRequestBodyPropertyConstructorFields({ parameters: parameters2, value: value2 }) {
+  getInlinedRequestBodyPropertyConstructorFields({ parameters: parameters2, value: value2, classReference: classReference4 }) {
     const fields = [];
     const bodyProperties = this.context.associateByWireValue({
       parameters: parameters2,
@@ -867497,7 +868130,7 @@ var EndpointSnippetGenerator2 = class extends WithGeneration {
     });
     for (const parameter6 of bodyProperties) {
       fields.push({
-        name: this.context.getPropertyName(parameter6.name.name),
+        name: this.context.resolvePropertyName(classReference4, parameter6.name.name),
         value: this.context.dynamicLiteralMapper.convert({
           ...parameter6,
           fallbackToDefault: parameter6.name.wireValue
@@ -867509,9 +868142,9 @@ var EndpointSnippetGenerator2 = class extends WithGeneration {
   getFileUploadRequestBodyConstructorFields({ filePropertyInfo }) {
     return [...filePropertyInfo.fileFields, ...filePropertyInfo.bodyPropertyFields];
   }
-  getReferencedRequestBodyPropertyConstructorField({ body, value: value2 }) {
+  getReferencedRequestBodyPropertyConstructorField({ body, value: value2, classReference: classReference4 }) {
     return {
-      name: this.context.getPropertyName(body.bodyKey),
+      name: this.context.resolvePropertyName(classReference4, body.bodyKey),
       value: this.getReferencedRequestBodyPropertyLiteral({ body: body.bodyType, value: value2 })
     };
   }
@@ -874445,7 +875078,7 @@ var EndpointSnippetGenerator4 = class {
       args.push(...pathParameterFields.map((field5) => field5.value));
     }
     if (!inlineFileProperties) {
-      args.push(...filePropertyInfo.fileFields.map((field5) => field5.value));
+      args.push(...filePropertyInfo.fileFields.map((field5) => java_exports.TypeLiteral.isNop(field5.value) ? java_exports.TypeLiteral.raw("null") : field5.value));
     }
     args.push(this.getInlinedRequestArg({
       request: request7,
@@ -890569,6 +891202,40 @@ init_lib4();
 function escapeSwiftStringLiteral(rawValue) {
   return rawValue.replace(/\\u([0-9a-fA-F]{4})/g, "\\u{$1}").replace(/(?<!\\)\\f/g, "\\u{000C}").replace(/(?<!\\)\\v/g, "\\u{000B}").replace(/(?<!\\)\\0/g, "\\u{0000}").replace(/(?<!\\)"/g, '\\"');
 }
+function escapeSwiftStringLiteralContent(value2) {
+  let result = "";
+  for (const ch of value2) {
+    switch (ch) {
+      case "\\":
+        result += "\\\\";
+        break;
+      case '"':
+        result += '\\"';
+        break;
+      case "\n":
+        result += "\\n";
+        break;
+      case "\r":
+        result += "\\r";
+        break;
+      case "	":
+        result += "\\t";
+        break;
+      case "\0":
+        result += "\\0";
+        break;
+      default: {
+        const code5 = ch.charCodeAt(0);
+        if (code5 < 32 || code5 === 127) {
+          result += `\\u{${code5.toString(16).toUpperCase()}}`;
+        } else {
+          result += ch;
+        }
+      }
+    }
+  }
+  return result;
+}
 
 // ../../../generators/swift/codegen/lib/syntax/reserved-keywords.js
 var reservedKeywords = [
@@ -890761,7 +891428,7 @@ var Expression2 = class extends AstNode8 {
         this.internalExpression.expression.write(writer2);
         break;
       case "string-literal":
-        writer2.write(`"${this.internalExpression.value}"`);
+        writer2.write(this.internalExpression.escape ? `"${escapeSwiftStringLiteralContent(this.internalExpression.value)}"` : `"${this.internalExpression.value}"`);
         break;
       case "number-literal":
         writer2.write(this.internalExpression.value.toString());
@@ -890900,6 +891567,17 @@ var Expression2 = class extends AstNode8 {
   static stringLiteral(value2) {
     return new this({ type: "string-literal", value: value2 });
   }
+  /**
+   * Like {@link Expression.stringLiteral}, but escapes characters in `value`
+   * that cannot appear unescaped inside a Swift `"..."` string literal
+   * (control characters, real newlines, real backslashes, real double quotes).
+   * Use this when `value` is raw user data (e.g. from JSON.parse), not a
+   * pre-formed Swift string literal containing intentional backslash
+   * sequences such as `\(...)` interpolation.
+   */
+  static escapedStringLiteral(value2) {
+    return new this({ type: "string-literal", value: value2, escape: true });
+  }
   static numberLiteral(value2) {
     return new this({ type: "number-literal", value: value2 });
   }
@@ -893071,7 +893749,7 @@ var DynamicTypeLiteralMapper6 = class {
           methodName: "string",
           arguments_: [
             swift_exports.functionArgument({
-              value: swift_exports.Expression.stringLiteral(value2)
+              value: swift_exports.Expression.escapedStringLiteral(value2)
             })
           ]
         });
@@ -893109,7 +893787,7 @@ var DynamicTypeLiteralMapper6 = class {
             swift_exports.functionArgument({
               value: swift_exports.Expression.dictionaryLiteral({
                 entries: Object.entries(value2).map(([key2, value3]) => [
-                  swift_exports.Expression.stringLiteral(key2),
+                  swift_exports.Expression.escapedStringLiteral(key2),
                   this.convertUnknown(value3)
                 ]),
                 multiline: true
@@ -893148,7 +893826,7 @@ var DynamicTypeLiteralMapper6 = class {
         if (str3 == null) {
           return swift_exports.Expression.nop();
         }
-        return swift_exports.Expression.stringLiteral(str3);
+        return swift_exports.Expression.escapedStringLiteral(str3);
       }
       case "DATE": {
         const date25 = this.context.getValueAsString({ value: value2 });
@@ -893181,7 +893859,7 @@ var DynamicTypeLiteralMapper6 = class {
         if (base643 == null) {
           return swift_exports.Expression.nop();
         }
-        return swift_exports.Expression.stringLiteral(base643);
+        return swift_exports.Expression.escapedStringLiteral(base643);
       }
       case "BIG_INTEGER": {
         const bigInt = this.context.getValueAsString({ value: value2 });
@@ -893724,7 +894402,7 @@ var EndpointSnippetGenerator9 = class {
       } else {
         return swift_exports.functionArgument({
           label: "baseURL",
-          value: swift_exports.Expression.stringLiteral(snippet2.baseURL)
+          value: swift_exports.Expression.escapedStringLiteral(snippet2.baseURL)
         });
       }
     }
@@ -893748,10 +894426,10 @@ var EndpointSnippetGenerator9 = class {
         }
         args.push(swift_exports.functionArgument({
           label: auth8.username.camelCase.unsafeName,
-          value: swift_exports.Expression.stringLiteral(values2.username)
+          value: swift_exports.Expression.escapedStringLiteral(values2.username)
         }), swift_exports.functionArgument({
           label: auth8.password.camelCase.unsafeName,
-          value: swift_exports.Expression.stringLiteral(values2.password)
+          value: swift_exports.Expression.escapedStringLiteral(values2.password)
         }));
         break;
       case "bearer":
@@ -893764,7 +894442,7 @@ var EndpointSnippetGenerator9 = class {
         }
         args.push(swift_exports.functionArgument({
           label: auth8.token.camelCase.unsafeName,
-          value: swift_exports.Expression.stringLiteral(values2.token)
+          value: swift_exports.Expression.escapedStringLiteral(values2.token)
         }));
         break;
       case "header":
@@ -919841,7 +920519,7 @@ var CliContext = class _CliContext {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "4.109.0";
+    return "5.0.0-10-g2ffb11338db";
   }
   getCliName() {
     if (false) {
@@ -928829,7 +929507,7 @@ ${errors4.map((e8) => `  - ${e8}`).join("\n")}`,
     collect2(raw.footer);
     if (raw.metadata != null && typeof raw.metadata === "object") {
       const meta5 = raw.metadata;
-      for (const imgKey of ["og:image", "twitter:image", "og:background-image", "og:logo"]) {
+      for (const imgKey of ["og:image", "twitter:image", "og:dynamic:background-image", "og:logo"]) {
         if (typeof meta5[imgKey] === "string") {
           collect2(meta5[imgKey]);
         }
@@ -928917,7 +929595,7 @@ ${errors4.map((e8) => `  - ${e8}`).join("\n")}`,
     cfg.footer = await field5(cfg.footer);
     if (cfg.metadata != null && typeof cfg.metadata === "object") {
       const meta5 = { ...cfg.metadata };
-      for (const imgKey of ["og:image", "twitter:image", "og:background-image", "og:logo"]) {
+      for (const imgKey of ["og:image", "twitter:image", "og:dynamic:background-image", "og:logo"]) {
         if (typeof meta5[imgKey] === "string") {
           meta5[imgKey] = await field5(meta5[imgKey]);
         }