@fern-api/fern-api-dev 4.65.0 → 4.65.1-2-g1c055b8c2af

package/cli.cjs

@@ -363097,9 +363097,9 @@ var require_diff3 = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/@fern-api+replay@0.9.1/node_modules/@fern-api/replay/dist/index.cjs
+// ../../../node_modules/.pnpm/@fern-api+replay@0.10.1/node_modules/@fern-api/replay/dist/index.cjs
 var require_dist14 = __commonJS({
-  "../../../node_modules/.pnpm/@fern-api+replay@0.9.1/node_modules/@fern-api/replay/dist/index.cjs"(exports2, module4) {
+  "../../../node_modules/.pnpm/@fern-api+replay@0.10.1/node_modules/@fern-api/replay/dist/index.cjs"(exports2, module4) {
     "use strict";
     var __defProp4 = Object.defineProperty;
     var __getOwnPropDesc4 = Object.getOwnPropertyDescriptor;
@@ -363496,6 +363496,7 @@ var require_dist14 = __commonJS({
       FernignoreMigrator: () => FernignoreMigrator,
       GitClient: () => GitClient2,
       LockfileManager: () => LockfileManager,
+      LockfileNotFoundError: () => LockfileNotFoundError,
       ReplayApplicator: () => ReplayApplicator,
       ReplayCommitter: () => ReplayCommitter,
       ReplayDetector: () => ReplayDetector,
@@ -363545,6 +363546,12 @@ var require_dist14 = __commonJS({
     var import_node_path41 = require("path");
     var import_yaml18 = require_dist9();
     var LOCKFILE_HEADER = "# DO NOT EDIT MANUALLY - Managed by Fern Replay\n";
+    var LockfileNotFoundError = class extends Error {
+      constructor(path98) {
+        super(`Lockfile not found: ${path98}`);
+        this.name = "LockfileNotFoundError";
+      }
+    };
     var LockfileManager = class {
       outputDir;
       lock = null;
@@ -363564,12 +363571,16 @@ var require_dist14 = __commonJS({
         if (this.lock) {
           return this.lock;
         }
-        if (!this.exists()) {
-          throw new Error(`Lockfile not found: ${this.lockfilePath}`);
+        try {
+          const content5 = (0, import_node_fs32.readFileSync)(this.lockfilePath, "utf-8");
+          this.lock = (0, import_yaml18.parse)(content5);
+          return this.lock;
+        } catch (error50) {
+          if (error50 instanceof Error && "code" in error50 && error50.code === "ENOENT") {
+            throw new LockfileNotFoundError(this.lockfilePath);
+          }
+          throw error50;
         }
-        const content5 = (0, import_node_fs32.readFileSync)(this.lockfilePath, "utf-8");
-        this.lock = (0, import_yaml18.parse)(content5);
-        return this.lock;
       }
       initialize(firstGeneration) {
         this.initializeInMemory(firstGeneration);
@@ -363713,13 +363724,21 @@ var require_dist14 = __commonJS({
         const exists2 = await this.git.commitExists(lastGen.commit_sha);
         if (!exists2) {
           this.warnings.push(
-            `Generation commit ${lastGen.commit_sha.slice(0, 7)} not found in git history. Skipping new patch detection. Existing lockfile patches will still be applied.`
+            `Generation commit ${lastGen.commit_sha.slice(0, 7)} not found in git history. Falling back to alternate detection.`
+          );
+          return this.detectPatchesViaTreeDiff(
+            lastGen,
+            /* commitKnownMissing */
+            true
           );
-          return { patches: [], revertedPatchIds: [] };
         }
         const isAncestor = await this.git.isAncestor(lastGen.commit_sha, "HEAD");
         if (!isAncestor) {
-          return this.detectPatchesViaTreeDiff(lastGen);
+          return this.detectPatchesViaTreeDiff(
+            lastGen,
+            /* commitKnownMissing */
+            false
+          );
         }
         const log4 = await this.git.exec([
           "log",
@@ -363745,7 +363764,15 @@ var require_dist14 = __commonJS({
           if (lock.patches.find((p10) => p10.original_commit === commit.sha)) {
             continue;
           }
-          const patchContent = await this.git.formatPatch(commit.sha);
+          let patchContent;
+          try {
+            patchContent = await this.git.formatPatch(commit.sha);
+          } catch {
+            this.warnings.push(
+              `Could not generate patch for commit ${commit.sha.slice(0, 7)} \u2014 it may be unreachable in a shallow clone. Skipping.`
+            );
+            continue;
+          }
           const contentHash = this.computeContentHash(patchContent);
           if (lock.patches.find((p10) => p10.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
             continue;
@@ -363838,11 +363865,15 @@ var require_dist14 = __commonJS({
        * Revert reconciliation is skipped here because tree-diff produces a single composite
        * patch from the aggregate diff — individual revert commits are not distinguishable.
        */
-      async detectPatchesViaTreeDiff(lastGen) {
-        const filesOutput = await this.git.exec(["diff", "--name-only", lastGen.commit_sha, "HEAD"]);
+      async detectPatchesViaTreeDiff(lastGen, commitKnownMissing) {
+        const diffBase = await this.resolveDiffBase(lastGen, commitKnownMissing);
+        if (!diffBase) {
+          return this.detectPatchesViaCommitScan();
+        }
+        const filesOutput = await this.git.exec(["diff", "--name-only", diffBase, "HEAD"]);
         const files = filesOutput.trim().split("\n").filter(Boolean).filter((f10) => !INFRASTRUCTURE_FILES.has(f10)).filter((f10) => !f10.startsWith(".fern/"));
         if (files.length === 0) return { patches: [], revertedPatchIds: [] };
-        const diff2 = await this.git.exec(["diff", lastGen.commit_sha, "HEAD", "--", ...files]);
+        const diff2 = await this.git.exec(["diff", diffBase, "HEAD", "--", ...files]);
         if (!diff2.trim()) return { patches: [], revertedPatchIds: [] };
         const contentHash = this.computeContentHash(diff2);
         const lock = this.lockManager.read();
@@ -363856,12 +363887,113 @@ var require_dist14 = __commonJS({
           original_commit: headSha,
           original_message: "Customer customizations (composite)",
           original_author: "composite",
-          base_generation: lastGen.commit_sha,
+          // Use diffBase when commit is unreachable — the applicator needs a reachable
+          // reference to find base file content. diffBase may be the tree_hash.
+          base_generation: commitKnownMissing ? diffBase : lastGen.commit_sha,
           files,
           patch_content: diff2
         };
         return { patches: [compositePatch], revertedPatchIds: [] };
       }
+      /**
+       * Last-resort detection when both generation commit and tree are unreachable.
+       * Scans all commits from HEAD, filters against known lockfile patches, and
+       * skips creation-only commits (squashed history after force push).
+       *
+       * Detected patches use the commit's parent as base_generation so the applicator
+       * can find base file content from the parent's tree (which IS reachable).
+       */
+      async detectPatchesViaCommitScan() {
+        const lock = this.lockManager.read();
+        const log4 = await this.git.exec([
+          "log",
+          "--max-count=200",
+          "--format=%H%x00%an%x00%ae%x00%s",
+          "HEAD",
+          "--",
+          this.sdkOutputDir
+        ]);
+        if (!log4.trim()) {
+          return { patches: [], revertedPatchIds: [] };
+        }
+        const commits = this.parseGitLog(log4);
+        const newPatches = [];
+        const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
+        const existingHashes = new Set(lock.patches.map((p10) => p10.content_hash));
+        const existingCommits = new Set(lock.patches.map((p10) => p10.original_commit));
+        for (const commit of commits) {
+          if (isGenerationCommit(commit)) {
+            continue;
+          }
+          const parents = await this.git.getCommitParents(commit.sha);
+          if (parents.length > 1) {
+            continue;
+          }
+          if (existingCommits.has(commit.sha)) {
+            continue;
+          }
+          let patchContent;
+          try {
+            patchContent = await this.git.formatPatch(commit.sha);
+          } catch {
+            continue;
+          }
+          const contentHash = this.computeContentHash(patchContent);
+          if (existingHashes.has(contentHash) || forgottenHashes.has(contentHash)) {
+            continue;
+          }
+          if (this.isCreationOnlyPatch(patchContent)) {
+            continue;
+          }
+          const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
+          const files = filesOutput.trim().split("\n").filter(Boolean).filter((f10) => !INFRASTRUCTURE_FILES.has(f10));
+          if (files.length === 0) {
+            continue;
+          }
+          if (parents.length === 0) {
+            continue;
+          }
+          const parentSha = parents[0];
+          newPatches.push({
+            id: `patch-${commit.sha.slice(0, 8)}`,
+            content_hash: contentHash,
+            original_commit: commit.sha,
+            original_message: commit.message,
+            original_author: `${commit.authorName} <${commit.authorEmail}>`,
+            base_generation: parentSha,
+            files,
+            patch_content: patchContent
+          });
+        }
+        newPatches.reverse();
+        return { patches: newPatches, revertedPatchIds: [] };
+      }
+      /**
+       * Check if a format-patch consists entirely of new-file creations.
+       * Used to identify squashed commits after force push, which create all files
+       * from scratch (--- /dev/null) rather than modifying existing files.
+       */
+      isCreationOnlyPatch(patchContent) {
+        const diffOldHeaders = patchContent.split("\n").filter((l14) => l14.startsWith("--- "));
+        if (diffOldHeaders.length === 0) {
+          return false;
+        }
+        return diffOldHeaders.every((l14) => l14 === "--- /dev/null");
+      }
+      /**
+       * Resolve the best available diff base for a generation record.
+       * Prefers commit_sha, falls back to tree_hash for unreachable commits.
+       * When commitKnownMissing is true, skips the redundant commitExists check.
+       */
+      async resolveDiffBase(gen, commitKnownMissing) {
+        if (!commitKnownMissing && await this.git.commitExists(gen.commit_sha)) {
+          return gen.commit_sha;
+        }
+        if (await this.git.treeExists(gen.tree_hash)) {
+          return gen.tree_hash;
+        }
+        return null;
+      }
       parseGitLog(log4) {
         return log4.trim().split("\n").map((line) => {
           const [sha, authorName, authorEmail, message] = line.split("\0");
@@ -363886,20 +364018,33 @@ var require_dist14 = __commonJS({
           outputLines.push(...region.ok);
           currentLine += region.ok.length;
         } else if (region.conflict) {
-          const startLine = currentLine;
-          outputLines.push("<<<<<<< Generated");
-          outputLines.push(...region.conflict.a);
-          outputLines.push("=======");
-          outputLines.push(...region.conflict.b);
-          outputLines.push(">>>>>>> Your customization");
-          const conflictLines = region.conflict.a.length + region.conflict.b.length + 3;
-          conflicts2.push({
-            startLine,
-            endLine: startLine + conflictLines - 1,
-            ours: region.conflict.a,
-            theirs: region.conflict.b
-          });
-          currentLine += conflictLines;
+          const resolved = tryResolveConflict(
+            region.conflict.a,
+            // ours (generator)
+            region.conflict.o,
+            // base
+            region.conflict.b
+            // theirs (user)
+          );
+          if (resolved !== null) {
+            outputLines.push(...resolved);
+            currentLine += resolved.length;
+          } else {
+            const startLine = currentLine;
+            outputLines.push("<<<<<<< Generated");
+            outputLines.push(...region.conflict.a);
+            outputLines.push("=======");
+            outputLines.push(...region.conflict.b);
+            outputLines.push(">>>>>>> Your customization");
+            const conflictLines = region.conflict.a.length + region.conflict.b.length + 3;
+            conflicts2.push({
+              startLine,
+              endLine: startLine + conflictLines - 1,
+              ours: region.conflict.a,
+              theirs: region.conflict.b
+            });
+            currentLine += conflictLines;
+          }
         }
       }
       return {
@@ -363908,33 +364053,134 @@ var require_dist14 = __commonJS({
         conflicts: conflicts2
       };
     }
+    function tryResolveConflict(oursLines, baseLines, theirsLines) {
+      if (baseLines.length === 0) {
+        return null;
+      }
+      const oursPatches = (0, import_node_diff3.diffPatch)(baseLines, oursLines);
+      const theirsPatches = (0, import_node_diff3.diffPatch)(baseLines, theirsLines);
+      if (oursPatches.length === 0) return theirsLines;
+      if (theirsPatches.length === 0) return oursLines;
+      if (patchesOverlap(oursPatches, theirsPatches)) {
+        return null;
+      }
+      return applyBothPatches(baseLines, oursPatches, theirsPatches);
+    }
+    function patchesOverlap(oursPatches, theirsPatches) {
+      for (const op5 of oursPatches) {
+        const oStart = op5.buffer1.offset;
+        const oEnd = oStart + op5.buffer1.length;
+        for (const tp3 of theirsPatches) {
+          const tStart = tp3.buffer1.offset;
+          const tEnd = tStart + tp3.buffer1.length;
+          if (op5.buffer1.length === 0 && tp3.buffer1.length === 0 && oStart === tStart) {
+            return true;
+          }
+          if (tp3.buffer1.length === 0 && tStart === oEnd) {
+            return true;
+          }
+          if (op5.buffer1.length === 0 && oStart === tEnd) {
+            return true;
+          }
+          if (oStart < tEnd && tStart < oEnd) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    function applyBothPatches(baseLines, oursPatches, theirsPatches) {
+      const allPatches = [
+        ...oursPatches.map((p10) => ({
+          offset: p10.buffer1.offset,
+          length: p10.buffer1.length,
+          replacement: p10.buffer2.chunk
+        })),
+        ...theirsPatches.map((p10) => ({
+          offset: p10.buffer1.offset,
+          length: p10.buffer1.length,
+          replacement: p10.buffer2.chunk
+        }))
+      ];
+      allPatches.sort((a10, b19) => b19.offset - a10.offset);
+      const result = [...baseLines];
+      for (const p10 of allPatches) {
+        result.splice(p10.offset, p10.length, ...p10.replacement);
+      }
+      return result;
+    }
     var import_promises182 = require("fs/promises");
     var import_node_os15 = require("os");
     var import_node_path210 = require("path");
     var import_minimatch8 = require_commonjs3();
+    var CONFLICT_OPENER = "<<<<<<< Generated";
+    var CONFLICT_SEPARATOR = "=======";
+    var CONFLICT_CLOSER = ">>>>>>> Your customization";
+    function trimCR(line) {
+      return line.endsWith("\r") ? line.slice(0, -1) : line;
+    }
+    function findConflictRanges(lines) {
+      const ranges = [];
+      let i11 = 0;
+      while (i11 < lines.length) {
+        if (trimCR(lines[i11]) === CONFLICT_OPENER) {
+          let separatorIdx = -1;
+          let j16 = i11 + 1;
+          let found = false;
+          while (j16 < lines.length) {
+            const trimmed2 = trimCR(lines[j16]);
+            if (trimmed2 === CONFLICT_OPENER) {
+              break;
+            }
+            if (separatorIdx === -1 && trimmed2 === CONFLICT_SEPARATOR) {
+              separatorIdx = j16;
+            } else if (separatorIdx !== -1 && trimmed2 === CONFLICT_CLOSER) {
+              ranges.push({ start: i11, separator: separatorIdx, end: j16 });
+              i11 = j16;
+              found = true;
+              break;
+            }
+            j16++;
+          }
+          if (!found) {
+            i11++;
+            continue;
+          }
+        }
+        i11++;
+      }
+      return ranges;
+    }
     function stripConflictMarkers(content5) {
-      const lines = content5.split("\n");
+      const lines = content5.split(/\r?\n/);
+      const ranges = findConflictRanges(lines);
+      if (ranges.length === 0) {
+        return content5;
+      }
       const result = [];
-      let inConflict = false;
-      let inOurs = false;
-      for (const line of lines) {
-        if (line.startsWith("<<<<<<< ")) {
-          inConflict = true;
-          inOurs = true;
-          continue;
-        }
-        if (inConflict && line === "=======") {
-          inOurs = false;
-          continue;
-        }
-        if (inConflict && line.startsWith(">>>>>>> ")) {
-          inConflict = false;
-          inOurs = false;
-          continue;
-        }
-        if (!inConflict || inOurs) {
-          result.push(line);
+      let rangeIdx = 0;
+      for (let i11 = 0; i11 < lines.length; i11++) {
+        if (rangeIdx < ranges.length) {
+          const range2 = ranges[rangeIdx];
+          if (i11 === range2.start) {
+            continue;
+          }
+          if (i11 > range2.start && i11 < range2.separator) {
+            result.push(lines[i11]);
+            continue;
+          }
+          if (i11 === range2.separator) {
+            continue;
+          }
+          if (i11 > range2.separator && i11 < range2.end) {
+            continue;
+          }
+          if (i11 === range2.end) {
+            rangeIdx++;
+            continue;
+          }
         }
+        result.push(lines[i11]);
       }
       return result.join("\n");
     }
@@ -363999,6 +364245,27 @@ var require_dist14 = __commonJS({
         this.lockManager = lockManager;
         this.outputDir = outputDir;
       }
+      /**
+       * Resolve the GenerationRecord for a patch's base_generation.
+       * Falls back to constructing an ad-hoc record from the commit's tree
+       * when base_generation isn't a tracked generation (commit-scan patches).
+       */
+      async resolveBaseGeneration(baseGeneration) {
+        const gen = this.lockManager.getGeneration(baseGeneration);
+        if (gen) return gen;
+        try {
+          const treeHash = await this.git.getTreeHash(baseGeneration);
+          return {
+            commit_sha: baseGeneration,
+            tree_hash: treeHash,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            cli_version: "unknown",
+            generator_versions: {}
+          };
+        } catch {
+          return void 0;
+        }
+      }
       /** Reset inter-patch accumulator for a new cycle. */
       resetAccumulator() {
         this.fileTheirsAccumulator.clear();
@@ -364080,7 +364347,7 @@ var require_dist14 = __commonJS({
         }
       }
       async applyPatchWithFallback(patch5) {
-        const baseGen = this.lockManager.getGeneration(patch5.base_generation);
+        const baseGen = await this.resolveBaseGeneration(patch5.base_generation);
         const lock = this.lockManager.read();
         const currentGen = lock.generations.find((g19) => g19.commit_sha === lock.current_generation);
         const currentTreeHash = currentGen?.tree_hash ?? baseGen?.tree_hash ?? "";
@@ -364164,7 +364431,7 @@ var require_dist14 = __commonJS({
       }
       async mergeFile(patch5, filePath, tempGit, tempDir2) {
         try {
-          const baseGen = this.lockManager.getGeneration(patch5.base_generation);
+          const baseGen = await this.resolveBaseGeneration(patch5.base_generation);
           if (!baseGen) {
             return { file: filePath, status: "skipped", reason: "base-generation-not-found" };
           }
@@ -364216,9 +364483,20 @@ var require_dist14 = __commonJS({
               renameSourcePath
             );
           }
+          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"
+              };
+            }
+          }
           let useAccumulatorAsMergeBase = false;
           const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
-          if (!theirs && accumulatorEntry) {
+          if (accumulatorEntry && (!theirs || base4 == null)) {
             theirs = await this.applyPatchToContent(
               accumulatorEntry.content,
               patch5.patch_content,
@@ -364230,6 +364508,17 @@ var require_dist14 = __commonJS({
               useAccumulatorAsMergeBase = true;
             }
           }
+          if (theirs) {
+            const theirsHasMarkers = theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization");
+            const accBaseHasMarkers = accumulatorEntry != null && (accumulatorEntry.content.includes("<<<<<<< Generated") || accumulatorEntry.content.includes(">>>>>>> Your customization"));
+            if (theirsHasMarkers && !accBaseHasMarkers && !(base4 != null && (base4.includes("<<<<<<< Generated") || base4.includes(">>>>>>> Your customization")))) {
+              return {
+                file: resolvedPath,
+                status: "skipped",
+                reason: "stale-conflict-markers"
+              };
+            }
+          }
           let effective_theirs = theirs;
           let baseMismatchSkipped = false;
           if (theirs && base4 && !useAccumulatorAsMergeBase) {
@@ -364249,12 +364538,16 @@ var require_dist14 = __commonJS({
             }
           }
           if (base4 == null && !ours && effective_theirs) {
+            this.fileTheirsAccumulator.set(resolvedPath, {
+              content: effective_theirs,
+              baseGeneration: patch5.base_generation
+            });
             const outDir2 = (0, import_node_path210.dirname)(oursPath);
             await (0, import_promises182.mkdir)(outDir2, { recursive: true });
             await (0, import_promises182.writeFile)(oursPath, effective_theirs);
             return { file: resolvedPath, status: "merged", reason: "new-file" };
           }
-          if (base4 == null && ours && effective_theirs) {
+          if (base4 == null && ours && effective_theirs && !useAccumulatorAsMergeBase) {
             const merged2 = threeWayMerge("", ours, effective_theirs);
             const outDir2 = (0, import_node_path210.dirname)(oursPath);
             await (0, import_promises182.mkdir)(outDir2, { recursive: true });
@@ -364296,7 +364589,7 @@ var require_dist14 = __commonJS({
           const outDir = (0, import_node_path210.dirname)(oursPath);
           await (0, import_promises182.mkdir)(outDir, { recursive: true });
           await (0, import_promises182.writeFile)(oursPath, merged.content);
-          if (effective_theirs) {
+          if (effective_theirs && !merged.hasConflicts) {
             this.fileTheirsAccumulator.set(resolvedPath, {
               content: effective_theirs,
               baseGeneration: patch5.base_generation
@@ -364437,16 +364730,24 @@ var require_dist14 = __commonJS({
         const addedLines = [];
         let inTargetFile = false;
         let inHunk = false;
+        let isNewFile = false;
         let noTrailingNewline = false;
         for (const line of lines) {
           if (line.startsWith("diff --git")) {
             if (inTargetFile) break;
             inTargetFile = isDiffLineForFile(line, filePath);
             inHunk = false;
+            isNewFile = false;
             continue;
           }
           if (!inTargetFile) continue;
+          if (!inHunk) {
+            if (line === "--- /dev/null" || line.startsWith("new file mode")) {
+              isNewFile = true;
+            }
+          }
           if (line.startsWith("@@")) {
+            if (!isNewFile) return null;
             inHunk = true;
             continue;
           }
@@ -364594,6 +364895,7 @@ CLI Version: ${options2.cliVersion}`;
           generator_versions: options2?.generatorVersions ?? {},
           base_branch_head: options2?.baseBranchHead
         };
+        let resolvedPatches;
         if (!this.lockManager.exists()) {
           this.lockManager.initializeInMemory(record21);
         } else {
@@ -364602,13 +364904,13 @@ CLI Version: ${options2.cliVersion}`;
             ...this.lockManager.getUnresolvedPatches(),
             ...this.lockManager.getResolvingPatches()
           ];
+          resolvedPatches = this.lockManager.getPatches().filter((p10) => p10.status == null);
           this.lockManager.addGeneration(record21);
           this.lockManager.clearPatches();
           for (const patch5 of unresolvedPatches) {
             this.lockManager.addPatch(patch5);
           }
         }
-        this.lockManager.save();
         try {
           const { patches: redetectedPatches } = await this.detector.detectNewPatches();
           if (redetectedPatches.length > 0) {
@@ -364622,20 +364924,27 @@ CLI Version: ${options2.cliVersion}`;
             for (const patch5 of redetectedPatches) {
               this.lockManager.addPatch(patch5);
             }
-            this.lockManager.save();
           }
-        } catch {
+        } catch (error50) {
+          for (const patch5 of resolvedPatches ?? []) {
+            this.lockManager.addPatch(patch5);
+          }
+          this.detector.warnings.push(
+            `Patch re-detection failed after divergent merge sync. ${(resolvedPatches ?? []).length} previously resolved patch(es) preserved. Error: ${error50 instanceof Error ? error50.message : String(error50)}`
+          );
         }
+        this.lockManager.save();
       }
       determineFlow() {
-        if (!this.lockManager.exists()) {
-          return "first-generation";
-        }
-        const lock = this.lockManager.read();
-        if (lock.patches.length === 0) {
-          return "no-patches";
+        try {
+          const lock = this.lockManager.read();
+          return lock.patches.length === 0 ? "no-patches" : "normal-regeneration";
+        } catch (error50) {
+          if (error50 instanceof LockfileNotFoundError) {
+            return "first-generation";
+          }
+          throw error50;
         }
-        return "normal-regeneration";
       }
       async handleFirstGeneration(options2) {
         if (options2?.dryRun) {
@@ -364677,12 +364986,17 @@ CLI Version: ${options2.cliVersion}`;
           baseBranchHead: options2.baseBranchHead
         } : void 0;
         await this.committer.commitGeneration("Update SDK (replay skipped)", commitOpts);
+        await this.cleanupStaleConflictMarkers();
         const genRecord = await this.committer.createGenerationRecord(commitOpts);
-        if (this.lockManager.exists()) {
+        try {
           this.lockManager.read();
           this.lockManager.addGeneration(genRecord);
-        } else {
-          this.lockManager.initializeInMemory(genRecord);
+        } catch (error50) {
+          if (error50 instanceof LockfileNotFoundError) {
+            this.lockManager.initializeInMemory(genRecord);
+          } else {
+            throw error50;
+          }
         }
         this.lockManager.setReplaySkippedAt((/* @__PURE__ */ new Date()).toISOString());
         this.lockManager.save();
@@ -364728,6 +365042,7 @@ CLI Version: ${options2.cliVersion}`;
           baseBranchHead: options2.baseBranchHead
         } : void 0;
         await this.committer.commitGeneration("Update SDK", commitOpts);
+        await this.cleanupStaleConflictMarkers();
         const genRecord = await this.committer.createGenerationRecord(commitOpts);
         this.lockManager.addGeneration(genRecord);
         let results = [];
@@ -364821,6 +365136,7 @@ CLI Version: ${options2.cliVersion}`;
           baseBranchHead: options2.baseBranchHead
         } : void 0;
         await this.committer.commitGeneration("Update SDK", commitOpts);
+        await this.cleanupStaleConflictMarkers();
         const genRecord = await this.committer.createGenerationRecord(commitOpts);
         this.lockManager.addGeneration(genRecord);
         const results = await this.applicator.applyPatches(allPatches);
@@ -365011,6 +365327,13 @@ CLI Version: ${options2.cliVersion}`;
                 contentRefreshed++;
                 continue;
               }
+              const diffLines = diff2.split("\n");
+              const hasStaleMarkers = diffLines.some(
+                (l14) => l14.startsWith("+<<<<<<< Generated") || l14.startsWith("+>>>>>>> Your customization")
+              );
+              if (hasStaleMarkers) {
+                continue;
+              }
               const newContentHash = this.detector.computeContentHash(diff2);
               if (newContentHash !== patch5.content_hash) {
                 const filesOutput = await this.git.exec(["diff", "--name-only", currentGen, "HEAD", "--", ...patch5.files]).catch(() => null);
@@ -365031,7 +365354,7 @@ CLI Version: ${options2.cliVersion}`;
             continue;
           }
           try {
-            const markerFiles = await this.git.exec(["grep", "-l", "<<<<<<<", "HEAD", "--", ...patch5.files]).catch(() => "");
+            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;
@@ -365071,6 +365394,25 @@ CLI Version: ${options2.cliVersion}`;
           }
         }
       }
+      /**
+       * Clean up stale conflict markers left by a previous crashed run.
+       * Called after commitGeneration() when HEAD is the [fern-generated] commit.
+       * Restores files to their clean generated state from HEAD.
+       * Skips .fernignore-protected files to prevent overwriting user content.
+       */
+      async cleanupStaleConflictMarkers() {
+        const markerFiles = await this.git.exec(["grep", "-l", "<<<<<<< Generated", "--", "."]).catch(() => "");
+        const files = markerFiles.trim().split("\n").filter(Boolean);
+        if (files.length === 0) return;
+        const fernignorePatterns = this.readFernignorePatterns();
+        for (const file4 of files) {
+          if (fernignorePatterns.some((pattern) => (0, import_minimatch22.minimatch)(file4, pattern))) continue;
+          try {
+            await this.git.exec(["checkout", "HEAD", "--", file4]);
+          } catch {
+          }
+        }
+      }
       readFernignorePatterns() {
         const fernignorePath = (0, import_node_path310.join)(this.outputDir, ".fernignore");
         if (!(0, import_node_fs210.existsSync)(fernignorePath)) return [];
@@ -603773,7 +604115,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "4.65.0",
+          version: "4.65.1-2-g1c055b8c2af",
           usingAccessToken: true
         }
       });
@@ -603824,7 +604166,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "4.65.0",
+        version: "4.65.1-2-g1c055b8c2af",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -754046,9 +754388,9 @@ var V66_TO_V65_MIGRATION = {
     [GeneratorName.TYPESCRIPT]: "3.61.0-rc.0",
     [GeneratorName.TYPESCRIPT_SDK]: "3.61.0-rc.0",
     [GeneratorName.TYPESCRIPT_EXPRESS]: "0.20.0-rc.0",
-    [GeneratorName.JAVA]: GeneratorWasNeverUpdatedToConsumeNewIR,
-    [GeneratorName.JAVA_MODEL]: GeneratorWasNeverUpdatedToConsumeNewIR,
-    [GeneratorName.JAVA_SDK]: GeneratorWasNeverUpdatedToConsumeNewIR,
+    [GeneratorName.JAVA]: "4.2.0-rc.0",
+    [GeneratorName.JAVA_MODEL]: "1.9.0-rc.0",
+    [GeneratorName.JAVA_SDK]: "4.2.0-rc.0",
     [GeneratorName.JAVA_SPRING]: GeneratorWasNeverUpdatedToConsumeNewIR,
     [GeneratorName.OPENAPI_PYTHON_CLIENT]: GeneratorWasNeverUpdatedToConsumeNewIR,
     [GeneratorName.OPENAPI]: "0.4.0-rc.0",
@@ -813707,6 +814049,8 @@ async function visitDocsConfigFileYamlAst({ contents, visitor, absoluteFilepathT
       if (navigation == null) {
         return;
       }
+      const navStart = performance.now();
+      context3.logger.debug("[docs-ast] Starting main navigation traversal...");
       await visitNavigationAst2({
         absolutePathToFernFolder,
         navigation,
@@ -813716,11 +814060,14 @@ async function visitDocsConfigFileYamlAst({ contents, visitor, absoluteFilepathT
         apiWorkspaces,
         context: context3
       });
+      context3.logger.debug(`[docs-ast] Main navigation traversal complete in ${(performance.now() - navStart).toFixed(0)}ms`);
     },
     products: async (products) => {
       if (products == null) {
         return;
       }
+      const productsStart = performance.now();
+      context3.logger.debug(`[docs-ast] Processing ${products.length} products...`);
       await Promise.all(products.map(async (product, idx) => {
         if ("path" in product) {
           await visitFilepath({
@@ -813752,6 +814099,7 @@ async function visitDocsConfigFileYamlAst({ contents, visitor, absoluteFilepathT
           }
         }
       }));
+      context3.logger.debug(`[docs-ast] Products processing complete in ${(performance.now() - productsStart).toFixed(0)}ms`);
     },
     check: noop2,
     redirects: noop2,
@@ -813801,6 +814149,8 @@ async function visitDocsConfigFileYamlAst({ contents, visitor, absoluteFilepathT
       if (versions == null) {
         return;
       }
+      const versionsStart = performance.now();
+      context3.logger.debug(`[docs-ast] Processing ${versions.length} versions...`);
       await Promise.all(versions.map(async (version7, idx) => {
         await visitFilepath({
           absoluteFilepathToConfiguration,
@@ -813830,6 +814180,7 @@ async function visitDocsConfigFileYamlAst({ contents, visitor, absoluteFilepathT
           });
         }
       }));
+      context3.logger.debug(`[docs-ast] Versions processing complete in ${(performance.now() - versionsStart).toFixed(0)}ms`);
     },
     roles: noop2,
     languages: noop2,
@@ -836168,42 +836519,46 @@ var ValidMarkdownLinks = {
           sourceResolver: new SourceResolverImpl(NOOP_CONTEXT2, fernWorkspace)
         });
         const api = toLatest(convertIrToApiDefinition({ ir: ir15, apiDefinitionId: (0, import_crypto9.randomUUID)(), context: NOOP_CONTEXT2 }));
+        const uniqueDescriptions = collectUniqueDescriptions(api);
         const violations = [];
-        for (const endpoint3 of endpoints) {
-          const descriptions = await collectDescriptions(api_definition_exports.prune(api, endpoint3));
-          for (const description of descriptions) {
-            const { pathnamesToCheck, violations: descriptionViolations } = collectPathnamesToCheck(description, { instanceUrls });
-            violations.push(...descriptionViolations);
-            const pathToCheckViolations = await Promise.all(pathnamesToCheck.map(async (pathnameToCheck) => {
-              const exists2 = await checkIfPathnameExists({
-                pathname: pathnameToCheck.pathname,
-                markdown: pathnameToCheck.markdown,
-                workspaceAbsoluteFilePath: workspace.absoluteFilePath,
-                pageSlugs: visitableSlugs,
-                absoluteFilePathsToSlugs,
-                redirects: workspace.config.redirects,
-                baseUrl
-              });
-              if (exists2 === true) {
-                return [];
-              }
-              return exists2.map((brokenPathname) => {
-                const [message, relFilePath] = createLinkViolationMessage({
-                  pathnameToCheck,
-                  targetPathname: brokenPathname,
-                  absoluteFilepathToWorkspace: workspace.absoluteFilePath
-                });
-                return {
-                  name: ValidMarkdownLinks.name,
-                  severity: "error",
-                  message,
-                  relFilepath: relFilePath
-                };
-              });
-            }));
-            violations.push(...pathToCheckViolations.flat());
+        const uniquePathnames = /* @__PURE__ */ new Map();
+        for (const description of uniqueDescriptions) {
+          const { pathnamesToCheck, violations: descriptionViolations } = collectPathnamesToCheck(description, { instanceUrls });
+          violations.push(...descriptionViolations);
+          for (const p10 of pathnamesToCheck) {
+            if (!uniquePathnames.has(p10.pathname)) {
+              uniquePathnames.set(p10.pathname, p10);
+            }
           }
         }
+        const pathToCheckViolations = await Promise.all([...uniquePathnames.values()].map(async (pathnameToCheck) => {
+          const exists2 = await checkIfPathnameExists({
+            pathname: pathnameToCheck.pathname,
+            markdown: pathnameToCheck.markdown,
+            workspaceAbsoluteFilePath: workspace.absoluteFilePath,
+            pageSlugs: visitableSlugs,
+            absoluteFilePathsToSlugs,
+            redirects: workspace.config.redirects,
+            baseUrl
+          });
+          if (exists2 === true) {
+            return [];
+          }
+          return exists2.map((brokenPathname) => {
+            const [message, relFilePath] = createLinkViolationMessage({
+              pathnameToCheck,
+              targetPathname: brokenPathname,
+              absoluteFilepathToWorkspace: workspace.absoluteFilePath
+            });
+            return {
+              name: ValidMarkdownLinks.name,
+              severity: "error",
+              message,
+              relFilepath: relFilePath
+            };
+          });
+        }));
+        violations.push(...pathToCheckViolations.flat());
         return violations;
       }
     };
@@ -836228,15 +836583,13 @@ function toLatest(apiDefinition) {
   const latest2 = api_definition_exports.ApiDefinitionV1ToLatest.from(apiDefinition).migrate();
   return latest2;
 }
-async function collectDescriptions(apiDefinition) {
-  const descriptions = [];
+function collectUniqueDescriptions(apiDefinition) {
+  const set25 = /* @__PURE__ */ new Set();
   api_definition_exports.Transformer.descriptions((description) => {
-    if (typeof description === "string") {
-      descriptions.push(description);
-    }
+    set25.add(description);
     return description;
   }).apiDefinition(apiDefinition);
-  return descriptions;
+  return set25;
 }
 
 // ../yaml/docs-validator/lib/rules/validate-product-file/validate-product-file.js
@@ -840794,7 +841147,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.65.0";
+  const version7 = "4.65.1-2-g1c055b8c2af";
   return `cli@${version7}`;
 }
 var DebugLogger = class {
@@ -851992,7 +852345,7 @@ var LegacyDocsPublisher = class {
         previewId,
         disableTemplates: void 0,
         skipUpload,
-        cliVersion: "4.65.0"
+        cliVersion: "4.65.1-2-g1c055b8c2af"
       });
       if (taskContext.getResult() === TaskResult.Failure) {
         return { success: false };
@@ -872557,10 +872910,16 @@ var DynamicLiteralMapper = class extends WithGeneration {
   }
   findMatchingUndiscriminatedUnionType({ undiscriminatedUnion: undiscriminatedUnion20, value }) {
     for (const typeReference2 of undiscriminatedUnion20.types) {
+      const errorsBefore = this.context.errors.size();
       try {
         const typeLiteral = this.convert({ typeReference: typeReference2, value });
+        if (is9.Literal.nop(typeLiteral) || this.context.errors.size() > errorsBefore) {
+          this.context.errors.truncate(errorsBefore);
+          continue;
+        }
         return { valueTypeReference: typeReference2, typeLiteral };
       } catch (e6) {
+        this.context.errors.truncate(errorsBefore);
         continue;
       }
     }
@@ -875981,13 +876340,16 @@ var DynamicTypeInstantiationMapper = class {
   }
   findMatchingUndiscriminatedUnionType({ undiscriminatedUnion: undiscriminatedUnion20, value }) {
     for (const typeReference2 of undiscriminatedUnion20.types) {
+      const errorsBefore = this.context.errors.size();
       try {
         const typeInstantiation = this.convert({ typeReference: typeReference2, value });
-        if (go_exports.TypeInstantiation.isNop(typeInstantiation)) {
+        if (go_exports.TypeInstantiation.isNop(typeInstantiation) || this.context.errors.size() > errorsBefore) {
+          this.context.errors.truncate(errorsBefore);
           continue;
         }
         return { valueTypeReference: typeReference2, typeInstantiation };
       } catch (e6) {
+        this.context.errors.truncate(errorsBefore);
         continue;
       }
     }
@@ -879191,40 +879553,29 @@ var DynamicTypeLiteralMapper = class {
     }));
   }
   findMatchingUndiscriminatedUnionType({ undiscriminatedUnion: undiscriminatedUnion20, value }) {
-    const attemptedVariants = [];
-    const variantErrors = [];
     for (const typeReference2 of undiscriminatedUnion20.types) {
       const errorsBefore = this.context.errors.size();
       try {
-        attemptedVariants.push(JSON.stringify(typeReference2));
         const typeInstantiation = this.convert({
           typeReference: typeReference2,
           value,
           inUndiscriminatedUnion: true
         });
-        if (java_exports.TypeLiteral.isNop(typeInstantiation)) {
+        if (java_exports.TypeLiteral.isNop(typeInstantiation) || this.context.errors.size() > errorsBefore) {
           this.context.errors.truncate(errorsBefore);
           continue;
         }
         return { valueTypeReference: typeReference2, typeInstantiation };
       } catch (e6) {
         this.context.errors.truncate(errorsBefore);
-        variantErrors.push(`Type ${JSON.stringify(typeReference2)}: ${extractErrorMessage(e6)}`);
         continue;
       }
     }
     this.context.errors.add({
       severity: Severity.Critical,
-      message: `None of the types in the undiscriminated union matched the given "${typeof value}" value. Tried ${attemptedVariants.length} variants. Errors: ${variantErrors.join("; ")}`
+      message: `None of the types in the undiscriminated union matched the given "${typeof value}" value`
     });
-    const unionName = undiscriminatedUnion20.declaration.name ?? "UnknownUnion";
-    const detailedErrors = variantErrors.map((error50, index3) => `  ${index3 + 1}. ${error50}`).join("\n");
-    throw new Error(`Failed to match undiscriminated union "${unionName}" for ${typeof value} value.
-Value: ${JSON.stringify(value)}
-Attempted ${attemptedVariants.length} variants:
-${detailedErrors}
-
-This prevents invalid snippet code generation that would cause formatter errors.`);
+    return void 0;
   }
   getUndiscriminatedUnionFieldName({ typeReference: typeReference2 }) {
     switch (typeReference2.type) {
@@ -901436,7 +901787,7 @@ var DynamicTypeLiteralMapper7 = class {
       const errorsBefore = this.context.errors.size();
       try {
         const result = this.convert({ typeReference: typeReference2, value, convertOpts });
-        if (typescript_exports.TypeLiteral.isNop(result)) {
+        if (typescript_exports.TypeLiteral.isNop(result) || this.context.errors.size() > errorsBefore) {
           this.context.errors.truncate(errorsBefore);
           continue;
         }
@@ -925583,7 +925934,7 @@ var CliContext = class {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "4.65.0";
+    return "4.65.1-2-g1c055b8c2af";
   }
   getCliName() {
     if (false) {

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.65.0",
+  "version": "4.65.1-2-g1c055b8c2af",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",