@fern-api/fern-api-dev 5.4.0 → 5.4.1

package/cli.cjs

@@ -340394,9 +340394,9 @@ var require_diff3 = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/@fern-api+replay@0.14.0/node_modules/@fern-api/replay/dist/index.cjs
+// ../../../node_modules/.pnpm/@fern-api+replay@0.14.1/node_modules/@fern-api/replay/dist/index.cjs
 var require_dist14 = __commonJS({
-  "../../../node_modules/.pnpm/@fern-api+replay@0.14.0/node_modules/@fern-api/replay/dist/index.cjs"(exports2, module4) {
+  "../../../node_modules/.pnpm/@fern-api+replay@0.14.1/node_modules/@fern-api/replay/dist/index.cjs"(exports2, module4) {
     "use strict";
     var __defProp4 = Object.defineProperty;
     var __getOwnPropDesc4 = Object.getOwnPropertyDescriptor;
@@ -340802,6 +340802,64 @@ var require_dist14 = __commonJS({
         "use strict";
       }
     });
+    var PatchApplyTheirs_exports = {};
+    __export4(PatchApplyTheirs_exports, {
+      applyPatchToContent: () => applyPatchToContent
+    });
+    async function applyPatchToContent(base4, patchContent, filePath) {
+      const fileDiff = extractFileDiff(patchContent, filePath);
+      if (!fileDiff) return null;
+      const tempDir2 = await (0, import_promises310.mkdtemp)((0, import_node_path42.join)((0, import_node_os32.tmpdir)(), "replay-migrate-"));
+      const tempGit = new GitClient(tempDir2);
+      try {
+        await tempGit.exec(["init"]);
+        await tempGit.exec(["config", "user.email", "migrate@fern.com"]);
+        await tempGit.exec(["config", "user.name", "Fern Replay Migration"]);
+        await tempGit.exec(["config", "commit.gpgSign", "false"]);
+        const tempFilePath = (0, import_node_path42.join)(tempDir2, filePath);
+        await (0, import_promises310.mkdir)((0, import_node_path42.dirname)(tempFilePath), { recursive: true });
+        await (0, import_promises310.writeFile)(tempFilePath, base4);
+        await tempGit.exec(["add", filePath]);
+        await tempGit.exec(["commit", "-m", `base for ${filePath}`, "--allow-empty"]);
+        await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
+        return await (0, import_promises310.readFile)(tempFilePath, "utf-8");
+      } catch {
+        return null;
+      } finally {
+        await (0, import_promises310.rm)(tempDir2, { recursive: true, force: true }).catch(() => {
+        });
+      }
+    }
+    function extractFileDiff(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;
+          const match3 = line.match(/^diff --git a\/.+ b\/(.+)$/);
+          if (match3 && match3[1] === filePath) {
+            inTarget = true;
+            out.push(line);
+          }
+          continue;
+        }
+        if (inTarget) out.push(line);
+      }
+      return out.length > 0 ? out.join("\n") + "\n" : null;
+    }
+    var import_promises310;
+    var import_node_os32;
+    var import_node_path42;
+    var init_PatchApplyTheirs = __esm3({
+      "src/PatchApplyTheirs.ts"() {
+        "use strict";
+        import_promises310 = require("fs/promises");
+        import_node_os32 = require("os");
+        import_node_path42 = require("path");
+        init_GitClient();
+      }
+    });
     var index_exports = {};
     __export4(index_exports, {
       CREDENTIAL_PATTERNS: () => CREDENTIAL_PATTERNS,
@@ -340892,7 +340950,7 @@ var require_dist14 = __commonJS({
       return match3?.[1];
     }
     var import_node_fs32 = require("fs");
-    var import_node_path42 = require("path");
+    var import_node_path43 = require("path");
     var import_yaml18 = require_dist9();
     var LOCKFILE_HEADER = "# DO NOT EDIT MANUALLY - Managed by Fern Replay\n";
     var LockfileNotFoundError = class extends Error {
@@ -340909,10 +340967,10 @@ var require_dist14 = __commonJS({
         this.outputDir = outputDir;
       }
       get lockfilePath() {
-        return (0, import_node_path42.join)(this.outputDir, ".fern", "replay.lock");
+        return (0, import_node_path43.join)(this.outputDir, ".fern", "replay.lock");
       }
       get customizationsPath() {
-        return (0, import_node_path42.join)(this.outputDir, ".fern", "replay.yml");
+        return (0, import_node_path43.join)(this.outputDir, ".fern", "replay.yml");
       }
       exists() {
         return (0, import_node_fs32.existsSync)(this.lockfilePath);
@@ -340956,7 +341014,17 @@ var require_dist14 = __commonJS({
         this.warnings.length = 0;
         const cleanPatches = [];
         for (const patch5 of this.lock.patches) {
-          const credentialMatches = scanForCredentials(patch5.patch_content);
+          const diffMatches = scanForCredentials(patch5.patch_content);
+          const snapshotMatches = [];
+          if (patch5.theirs_snapshot) {
+            for (const content22 of Object.values(patch5.theirs_snapshot)) {
+              const m7 = scanForCredentials(content22);
+              for (const x5 of m7) {
+                if (!snapshotMatches.includes(x5)) snapshotMatches.push(x5);
+              }
+            }
+          }
+          const credentialMatches = [...diffMatches, ...snapshotMatches.filter((m7) => !diffMatches.includes(m7))];
           const sensitiveFiles = patch5.files.filter((f5) => isSensitiveFile(f5));
           if (credentialMatches.length > 0 || sensitiveFiles.length > 0) {
             const reasons = [];
@@ -340974,7 +341042,7 @@ var require_dist14 = __commonJS({
           }
         }
         this.lock.patches = cleanPatches;
-        const dir = (0, import_node_path42.dirname)(this.lockfilePath);
+        const dir = (0, import_node_path43.dirname)(this.lockfilePath);
         if (!(0, import_node_fs32.existsSync)(dir)) {
           (0, import_node_fs32.mkdirSync)(dir, { recursive: true });
         }
@@ -341075,572 +341143,81 @@ var require_dist14 = __commonJS({
       }
     };
     var import_node_crypto7 = require("crypto");
-    var INFRASTRUCTURE_FILES = /* @__PURE__ */ new Set([".fernignore"]);
-    function parsePatchFileHeaders(patchContent) {
-      const results = [];
-      let currentPath = null;
-      let currentIsCreate = false;
-      let currentIsDelete = false;
-      const flush3 = () => {
-        if (currentPath !== null) {
-          results.push({ path: currentPath, isCreate: currentIsCreate, isDelete: currentIsDelete });
-        }
-      };
-      for (const line of patchContent.split("\n")) {
-        if (line.startsWith("diff --git ")) {
-          flush3();
-          currentPath = null;
-          currentIsCreate = false;
-          currentIsDelete = false;
-          const match3 = line.match(/^diff --git a\/(.+?) b\/(.+?)$/);
-          if (match3) {
-            currentPath = match3[2] ?? null;
-          }
-        } else if (currentPath !== null) {
-          if (line.startsWith("new file mode ")) {
-            currentIsCreate = true;
-          } else if (line.startsWith("deleted file mode ")) {
-            currentIsDelete = true;
-          }
-        }
-      }
-      flush3();
-      return results;
+    var import_promises193 = 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;
     }
-    var ReplayDetector = class {
-      git;
-      lockManager;
-      sdkOutputDir;
-      warnings = [];
-      constructor(git, lockManager, sdkOutputDir) {
-        this.git = git;
-        this.lockManager = lockManager;
-        this.sdkOutputDir = sdkOutputDir;
-      }
-      async detectNewPatches() {
-        const lock = this.lockManager.read();
-        const lastGen = this.getLastGeneration(lock);
-        if (!lastGen) {
-          return { patches: [], revertedPatchIds: [] };
-        }
-        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. Falling back to alternate detection.`
-          );
-          return this.detectPatchesViaTreeDiff(
-            lastGen,
-            /* commitKnownMissing */
-            true
-          );
-        }
-        const isAncestor = await this.git.isAncestor(lastGen.commit_sha, "HEAD");
-        if (!isAncestor) {
-          return this.detectPatchesViaMergeBase(lastGen, lock);
-        }
-        return this.detectPatchesInRange(lastGen.commit_sha, lastGen, lock);
-      }
-      /**
-       * FER-10201 — Non-linear-history detection via `merge-base(prevGen, HEAD)`.
-       *
-       * After a squash-merge of a Fern-bot PR, `lastGen.commit_sha` (the previous
-       * `[fern-generated]`) is orphaned but still in git's object database. The
-       * merge-base is the commit on main from which the bot's branch was created —
-       * a reachable ancestor of HEAD. Walking that range and classifying each
-       * commit via `isGenerationCommit` mirrors the linear path and eliminates
-       * the bug class where pipeline-driven changes (autoversion, replay,
-       * generation) get bundled as customer customizations.
-       *
-       * Falls through to the legacy composite path when no common ancestor exists
-       * (truly disjoint history — orphan branches with no shared root).
-       */
-      async detectPatchesViaMergeBase(lastGen, lock) {
-        let mergeBase = "";
-        try {
-          mergeBase = (await this.git.exec(["merge-base", lastGen.commit_sha, "HEAD"])).trim();
-        } catch {
-        }
-        if (!mergeBase) {
-          this.warnings.push(
-            `No common ancestor between previous generation ${lastGen.commit_sha.slice(0, 7)} and HEAD. Falling back to composite tree-diff detection.`
-          );
-          return this.detectPatchesViaTreeDiff(
-            lastGen,
-            /* commitKnownMissing */
-            false
-          );
-        }
-        return this.detectPatchesInRange(mergeBase, lastGen, lock);
-      }
-      /**
-       * FER-10201 — Walk `${rangeStart}..HEAD`, classify each commit, emit one
-       * `StoredPatch` per customer commit. Body shared by the linear path
-       * (rangeStart = lastGen.commit_sha) and the merge-base path.
-       *
-       * Patch `base_generation` is always `lastGen.commit_sha` — the
-       * lockfile-tracked reference the applicator uses to fetch base file
-       * content, regardless of where the walk actually started.
-       */
-      async detectPatchesInRange(rangeStart, lastGen, lock) {
-        const log4 = await this.git.exec([
-          "log",
-          "--first-parent",
-          "--format=%H%x00%an%x00%ae%x00%s",
-          `${rangeStart}..HEAD`,
-          "--",
-          this.sdkOutputDir
-        ]);
-        if (!log4.trim()) {
-          return { patches: [], revertedPatchIds: [] };
-        }
-        const commits = this.parseGitLog(log4);
-        const newPatches = [];
-        const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
-        for (const commit of commits) {
-          if (isGenerationCommit(commit)) {
-            continue;
-          }
-          if (lock.patches.find((p14) => p14.original_commit === commit.sha)) {
-            continue;
-          }
-          const parents = await this.git.getCommitParents(commit.sha);
-          if (parents.length > 1) {
-            const compositePatch = await this.createMergeCompositePatch({
-              mergeCommit: commit,
-              firstParent: parents[0],
-              lastGen,
-              lock
-            });
-            if (compositePatch) {
-              newPatches.push(compositePatch);
+    function findConflictRanges(lines) {
+      const ranges = [];
+      let i9 = 0;
+      while (i9 < lines.length) {
+        if (trimCR(lines[i9]) === CONFLICT_OPENER) {
+          let separatorIdx = -1;
+          let j7 = i9 + 1;
+          let found = false;
+          while (j7 < lines.length) {
+            const trimmed2 = trimCR(lines[j7]);
+            if (trimmed2 === CONFLICT_OPENER) {
+              break;
             }
-            continue;
-          }
-          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;
-          }
-          let contentHash = this.computeContentHash(patchContent);
-          if (lock.patches.find((p14) => p14.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
-            continue;
-          }
-          const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
-          const allFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f5) => !INFRASTRUCTURE_FILES.has(f5)).filter((f5) => !f5.startsWith(".fern/"));
-          const sensitiveFiles = allFiles.filter((f5) => isSensitiveFile(f5));
-          const files = allFiles.filter((f5) => !isSensitiveFile(f5));
-          if (sensitiveFiles.length > 0) {
-            this.warnings.push(
-              `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveFiles.join(", ")}. These files will not be tracked by replay.`
-            );
-            if (files.length > 0) {
-              const parentSha = parents[0];
-              if (parentSha) {
-                try {
-                  patchContent = await this.git.exec(["diff", parentSha, commit.sha, "--", ...files]);
-                } catch {
-                  continue;
-                }
-                if (!patchContent.trim()) continue;
-                contentHash = this.computeContentHash(patchContent);
-              }
+            if (separatorIdx === -1 && trimmed2 === CONFLICT_SEPARATOR) {
+              separatorIdx = j7;
+            } else if (separatorIdx !== -1 && trimmed2 === CONFLICT_CLOSER) {
+              ranges.push({ start: i9, separator: separatorIdx, end: j7 });
+              i9 = j7;
+              found = true;
+              break;
             }
+            j7++;
           }
-          if (files.length === 0) {
+          if (!found) {
+            i9++;
             continue;
           }
-          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: lastGen.commit_sha,
-            files,
-            patch_content: patchContent,
-            ...this.isCreationOnlyPatch(patchContent) ? { user_owned: true } : {}
-          });
-        }
-        const survivingPatches = await this.collapseNetZeroFiles(newPatches);
-        survivingPatches.reverse();
-        const revertedPatchIdSet = /* @__PURE__ */ new Set();
-        const revertIndicesToRemove = /* @__PURE__ */ new Set();
-        for (let i9 = 0; i9 < survivingPatches.length; i9++) {
-          const patch5 = survivingPatches[i9];
-          if (!isRevertCommit(patch5.original_message)) continue;
-          let body = "";
-          try {
-            body = await this.git.getCommitBody(patch5.original_commit);
-          } catch {
-          }
-          const revertedSha = parseRevertedSha(body);
-          const revertedMessage = parseRevertedMessage(patch5.original_message);
-          let matchedExisting = false;
-          if (revertedSha) {
-            const existing = lock.patches.find((p14) => p14.original_commit === revertedSha);
-            if (existing) {
-              revertedPatchIdSet.add(existing.id);
-              revertIndicesToRemove.add(i9);
-              matchedExisting = true;
-            }
-          }
-          if (!matchedExisting && revertedMessage) {
-            const existing = lock.patches.find((p14) => p14.original_message === revertedMessage);
-            if (existing) {
-              revertedPatchIdSet.add(existing.id);
-              revertIndicesToRemove.add(i9);
-              matchedExisting = true;
-            }
-          }
-          if (matchedExisting) continue;
-          let matchedNew = false;
-          if (revertedSha) {
-            const idx = survivingPatches.findIndex(
-              (p14, j7) => j7 !== i9 && !revertIndicesToRemove.has(j7) && p14.original_commit === revertedSha
-            );
-            if (idx !== -1) {
-              revertIndicesToRemove.add(i9);
-              revertIndicesToRemove.add(idx);
-              matchedNew = true;
-            }
-          }
-          if (!matchedNew && revertedMessage) {
-            const idx = survivingPatches.findIndex(
-              (p14, j7) => j7 !== i9 && !revertIndicesToRemove.has(j7) && p14.original_message === revertedMessage
-            );
-            if (idx !== -1) {
-              revertIndicesToRemove.add(i9);
-              revertIndicesToRemove.add(idx);
-            }
-          }
-          if (!matchedExisting && !matchedNew) {
-            revertIndicesToRemove.add(i9);
-          }
         }
-        const filteredPatches = survivingPatches.filter((_7, i9) => !revertIndicesToRemove.has(i9));
-        return { patches: filteredPatches, revertedPatchIds: [...revertedPatchIdSet] };
-      }
-      /**
-       * Compute content hash for deduplication.
-       *
-       * Produces a format-agnostic hash so both `git format-patch` output
-       * (email-wrapped) and plain `git diff` output hash to the same value
-       * when the underlying diff hunks are identical.
-       *
-       * Normalization:
-       *   1. Strip email wrapper: everything before the first `diff --git` line
-       *      (From:, Subject:, Date:, diffstat, blank separators).
-       *   2. Strip `index` lines (blob SHA pairs change across rebases).
-       *   3. Strip trailing git version marker (`-- \n<version>`).
-       *
-       * This ensures content hashes match across the no-patches and normal-
-       * regeneration flows, which store formatPatch and git-diff formats
-       * respectively (FER-9850, D5-D9).
-       */
-      computeContentHash(patchContent) {
-        const lines = patchContent.split("\n");
-        const diffStart = lines.findIndex((l9) => l9.startsWith("diff --git "));
-        const relevantLines = diffStart > 0 ? lines.slice(diffStart) : lines;
-        const normalized = relevantLines.filter((line) => !line.startsWith("index ")).join("\n").replace(/\n-- \n[\d]+\.[\d]+[^\n]*\s*$/, "");
-        return `sha256:${(0, import_node_crypto7.createHash)("sha256").update(normalized).digest("hex")}`;
-      }
-      /**
-       * FER-9805 — Drop patches whose files were transiently created and then
-       * deleted within the current linear detection window, and are absent from
-       * HEAD at the end of the window.
-       *
-       * Rationale: on a merge commit, createMergeCompositePatch already diffs
-       * firstParent..mergeCommit so net-zero files never enter the composite. On
-       * linear history each commit becomes its own patch, so a file that was
-       * briefly added and later removed survives as a create+delete pair whose
-       * cumulative diff is empty. We drop such patches before they reach the
-       * lockfile.
-       *
-       * A file is "transient" when:
-       *   1. some patch in the window sets `new file mode` for it (a creation), AND
-       *   2. some patch in the window sets `deleted file mode` for it (a deletion), AND
-       *   3. it is absent from HEAD's tree.
-       *
-       * The HEAD guard (#3) prevents false positives when a file is deleted
-       * and then recreated with different content — the cumulative diff of
-       * such a pair is non-empty and must be preserved.
-       *
-       * This only drops patches whose `files` are a subset of the transient
-       * set. A partial-transient patch (one that touches a transient file
-       * alongside a persistent one) is left unmodified; surgical stripping of
-       * single files from a multi-file patch would require a follow-up that
-       * regenerates the patch content via `git format-patch -- <files>`. No
-       * current failing test exercises this, and leaving the patch intact
-       * preserves today's behaviour. TODO(FER-9805): revisit if a future
-       * adversarial test demands per-file stripping.
-       */
-      async collapseNetZeroFiles(patches) {
-        if (patches.length === 0) return patches;
-        const stateByFile = /* @__PURE__ */ new Map();
-        for (const patch5 of patches) {
-          for (const header of parsePatchFileHeaders(patch5.patch_content)) {
-            if (!header.isCreate && !header.isDelete) continue;
-            const prior = stateByFile.get(header.path) ?? { created: false, deleted: false };
-            if (header.isCreate) prior.created = true;
-            if (header.isDelete) prior.deleted = true;
-            stateByFile.set(header.path, prior);
-          }
-        }
-        let anyCandidate = false;
-        for (const state of stateByFile.values()) {
-          if (state.created && state.deleted) {
-            anyCandidate = true;
-            break;
-          }
-        }
-        if (!anyCandidate) return patches;
-        const headFiles = await this.listHeadFiles();
-        const transient = /* @__PURE__ */ new Set();
-        for (const [file4, state] of stateByFile) {
-          if (state.created && state.deleted && !headFiles.has(file4)) {
-            transient.add(file4);
-          }
-        }
-        if (transient.size === 0) return patches;
-        return patches.filter((patch5) => !patch5.files.every((f5) => transient.has(f5)));
-      }
-      /**
-       * List every tracked path at HEAD (one `git ls-tree -r` invocation).
-       * Returns an empty Set if HEAD is unborn or the invocation fails — the
-       * caller then treats every candidate as "not in HEAD" and may collapse
-       * more aggressively. On typical SDK repos this is a single sub-10ms call.
-       */
-      async listHeadFiles() {
-        try {
-          const out = await this.git.exec(["ls-tree", "-r", "--name-only", "HEAD"]);
-          return new Set(out.split("\n").map((l9) => l9.trim()).filter(Boolean));
-        } catch {
-          return /* @__PURE__ */ new Set();
-        }
-      }
-      /**
-       * Create a single composite patch for a merge commit by diffing the merge
-       * commit against its first parent. This captures the net change of the
-       * entire merged branch as one patch, eliminating accumulator chaining and
-       * zero-net-change ghost conflicts.
-       */
-      async createMergeCompositePatch(input3) {
-        const { mergeCommit, firstParent, lastGen, lock } = input3;
-        const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
-        const filesOutput = await this.git.exec([
-          "diff",
-          "--name-only",
-          firstParent,
-          mergeCommit.sha
-        ]);
-        const allMergeFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f5) => !INFRASTRUCTURE_FILES.has(f5)).filter((f5) => !f5.startsWith(".fern/"));
-        const sensitiveMergeFiles = allMergeFiles.filter((f5) => isSensitiveFile(f5));
-        const files = allMergeFiles.filter((f5) => !isSensitiveFile(f5));
-        if (sensitiveMergeFiles.length > 0) {
-          this.warnings.push(
-            `Sensitive file(s) excluded from merge patch for commit ${mergeCommit.sha.slice(0, 7)}: ${sensitiveMergeFiles.join(", ")}. These files will not be tracked by replay.`
-          );
-        }
-        if (files.length === 0) return null;
-        const diff2 = await this.git.exec([
-          "diff",
-          firstParent,
-          mergeCommit.sha,
-          "--",
-          ...files
-        ]);
-        if (!diff2.trim()) return null;
-        const contentHash = this.computeContentHash(diff2);
-        if (lock.patches.some((p14) => p14.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
-          return null;
-        }
-        return {
-          id: `patch-merge-${mergeCommit.sha.slice(0, 8)}`,
-          content_hash: contentHash,
-          original_commit: mergeCommit.sha,
-          original_message: mergeCommit.message,
-          original_author: `${mergeCommit.authorName} <${mergeCommit.authorEmail}>`,
-          base_generation: lastGen.commit_sha,
-          files,
-          patch_content: diff2,
-          ...this.isCreationOnlyPatch(diff2) ? { user_owned: true } : {}
-        };
+        i9++;
       }
-      /**
-       * Detect patches via tree diff for non-linear history. Returns a composite patch.
-       * 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, 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 allTreeFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f5) => !INFRASTRUCTURE_FILES.has(f5)).filter((f5) => !f5.startsWith(".fern/"));
-        const sensitiveTreeFiles = allTreeFiles.filter((f5) => isSensitiveFile(f5));
-        const files = allTreeFiles.filter((f5) => !isSensitiveFile(f5));
-        if (sensitiveTreeFiles.length > 0) {
-          this.warnings.push(
-            `Sensitive file(s) excluded from composite patch: ${sensitiveTreeFiles.join(", ")}. These files will not be tracked by replay.`
-          );
-        }
-        if (files.length === 0) return { patches: [], revertedPatchIds: [] };
-        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();
-        if (lock.patches.some((p14) => p14.content_hash === contentHash) || (lock.forgotten_hashes ?? []).includes(contentHash)) {
-          return { patches: [], revertedPatchIds: [] };
-        }
-        const headSha = (await this.git.exec(["rev-parse", "HEAD"])).trim();
-        const compositePatch = {
-          id: `patch-composite-${headSha.slice(0, 8)}`,
-          content_hash: contentHash,
-          original_commit: headSha,
-          original_message: "Customer customizations (composite)",
-          original_author: "composite",
-          // 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,
-          ...this.isCreationOnlyPatch(diff2) ? { user_owned: true } : {}
-        };
-        return { patches: [compositePatch], revertedPatchIds: [] };
+      return ranges;
+    }
+    function stripConflictMarkers(content5) {
+      const lines = content5.split(/\r?\n/);
+      const ranges = findConflictRanges(lines);
+      if (ranges.length === 0) {
+        return content5;
       }
-      /**
-       * 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((p14) => p14.content_hash));
-        const existingCommits = new Set(lock.patches.map((p14) => p14.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 {
+      const result = [];
+      let rangeIdx = 0;
+      for (let i9 = 0; i9 < lines.length; i9++) {
+        if (rangeIdx < ranges.length) {
+          const range2 = ranges[rangeIdx];
+          if (i9 === range2.start) {
             continue;
           }
-          let contentHash = this.computeContentHash(patchContent);
-          if (existingHashes.has(contentHash) || forgottenHashes.has(contentHash)) {
+          if (i9 > range2.start && i9 < range2.separator) {
+            result.push(lines[i9]);
             continue;
           }
-          if (this.isCreationOnlyPatch(patchContent)) {
+          if (i9 === range2.separator) {
             continue;
           }
-          const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
-          const allScanFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f5) => !INFRASTRUCTURE_FILES.has(f5));
-          const sensitiveScanFiles = allScanFiles.filter((f5) => isSensitiveFile(f5));
-          const files = allScanFiles.filter((f5) => !isSensitiveFile(f5));
-          if (sensitiveScanFiles.length > 0) {
-            this.warnings.push(
-              `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveScanFiles.join(", ")}. These files will not be tracked by replay.`
-            );
-            if (files.length > 0) {
-              if (parents.length === 0) {
-                continue;
-              }
-              try {
-                patchContent = await this.git.exec(["diff", parents[0], commit.sha, "--", ...files]);
-              } catch {
-                continue;
-              }
-              if (!patchContent.trim()) continue;
-              contentHash = this.computeContentHash(patchContent);
-            }
-          }
-          if (files.length === 0) {
+          if (i9 > range2.separator && i9 < range2.end) {
             continue;
           }
-          if (parents.length === 0) {
+          if (i9 === range2.end) {
+            rangeIdx++;
             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((l9) => l9.startsWith("--- "));
-        if (diffOldHeaders.length === 0) {
-          return false;
-        }
-        return diffOldHeaders.every((l9) => l9 === "--- /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");
-          return { sha, authorName, authorEmail, message };
-        });
-      }
-      getLastGeneration(lock) {
-        return lock.generations.find((g8) => g8.commit_sha === lock.current_generation);
+        result.push(lines[i9]);
       }
-    };
+      return result.join("\n");
+    }
     var import_node_diff3 = require_diff3();
     function threeWayMerge(base4, ours, theirs) {
       const baseLines = base4.split("\n");
@@ -341778,81 +341355,6 @@ var require_dist14 = __commonJS({
       }
       return result;
     }
-    var import_promises193 = 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 i9 = 0;
-      while (i9 < lines.length) {
-        if (trimCR(lines[i9]) === CONFLICT_OPENER) {
-          let separatorIdx = -1;
-          let j7 = i9 + 1;
-          let found = false;
-          while (j7 < lines.length) {
-            const trimmed2 = trimCR(lines[j7]);
-            if (trimmed2 === CONFLICT_OPENER) {
-              break;
-            }
-            if (separatorIdx === -1 && trimmed2 === CONFLICT_SEPARATOR) {
-              separatorIdx = j7;
-            } else if (separatorIdx !== -1 && trimmed2 === CONFLICT_CLOSER) {
-              ranges.push({ start: i9, separator: separatorIdx, end: j7 });
-              i9 = j7;
-              found = true;
-              break;
-            }
-            j7++;
-          }
-          if (!found) {
-            i9++;
-            continue;
-          }
-        }
-        i9++;
-      }
-      return ranges;
-    }
-    function stripConflictMarkers(content5) {
-      const lines = content5.split(/\r?\n/);
-      const ranges = findConflictRanges(lines);
-      if (ranges.length === 0) {
-        return content5;
-      }
-      const result = [];
-      let rangeIdx = 0;
-      for (let i9 = 0; i9 < lines.length; i9++) {
-        if (rangeIdx < ranges.length) {
-          const range2 = ranges[rangeIdx];
-          if (i9 === range2.start) {
-            continue;
-          }
-          if (i9 > range2.start && i9 < range2.separator) {
-            result.push(lines[i9]);
-            continue;
-          }
-          if (i9 === range2.separator) {
-            continue;
-          }
-          if (i9 > range2.separator && i9 < range2.end) {
-            continue;
-          }
-          if (i9 === range2.end) {
-            rangeIdx++;
-            continue;
-          }
-        }
-        result.push(lines[i9]);
-      }
-      return result.join("\n");
-    }
     var BINARY_EXTENSIONS2 = /* @__PURE__ */ new Set([
       ".png",
       ".jpg",
@@ -341922,6 +341424,26 @@ var require_dist14 = __commonJS({
        *     cross-patch context mismatch
        */
       currentApplyMode = "replay";
+      /**
+       * Set of files that appear in 2+ patches in the current `applyPatches`
+       * invocation. Computed at the top of `applyPatches`. Read by `mergeFile`
+       * and `populateAccumulatorForPatch` to decide whether to use the patch's
+       * `theirs_snapshot` directly as THEIRS (snapshot-as-primary) or fall
+       * back to line-anchored reconstruction (FER-9525 cross-patch isolation).
+       *
+       * Snapshot-as-primary is correct when the patch owns its file (no other
+       * patch in this run touches it): the snapshot is what the customer
+       * intends for that file post-regen, regardless of generator structural
+       * changes that would invalidate the diff's line anchors.
+       *
+       * When a file IS shared, snapshots are CUMULATIVE across the patches
+       * touching it (each one's snapshot includes prior patches' contributions).
+       * Using a later patch's cumulative snapshot as its individual THEIRS
+       * would propagate prior patches' edits into the merge — surfacing nested
+       * conflicts at regions the patch alone never touched. Reconstruction
+       * via `applyPatchToContent` is required there.
+       */
+      sharedFiles = /* @__PURE__ */ new Set();
       constructor(git, lockManager, outputDir) {
         this.git = git;
         this.lockManager = lockManager;
@@ -341987,6 +341509,15 @@ var require_dist14 = __commonJS({
         const applyMode = opts?.applyMode ?? "replay";
         this.currentApplyMode = applyMode;
         this.resetAccumulator();
+        const fileFreq = /* @__PURE__ */ new Map();
+        for (const p14 of patches) {
+          for (const f5 of p14.files) {
+            fileFreq.set(f5, (fileFreq.get(f5) ?? 0) + 1);
+          }
+        }
+        this.sharedFiles = new Set(
+          Array.from(fileFreq.entries()).filter(([, n19]) => n19 > 1).map(([f5]) => f5)
+        );
         const results = [];
         for (let i9 = 0; i9 < patches.length; i9++) {
           const patch5 = patches[i9];
@@ -342052,7 +341583,9 @@ var require_dist14 = __commonJS({
             if (isBinaryFile(filePath)) continue;
             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 snapshotForFile = patch5.theirs_snapshot?.[resolvedPath] ?? patch5.theirs_snapshot?.[filePath];
+            const fileIsShared = this.sharedFiles.has(resolvedPath) || this.sharedFiles.has(filePath);
+            const theirs = !fileIsShared && snapshotForFile != null ? snapshotForFile : await this.applyPatchToContent(base4, patch5.patch_content, filePath, tempGit, tempDir2);
             const finalOnDisk = await (0, import_promises193.readFile)((0, import_node_path210.join)(this.outputDir, resolvedPath), "utf-8").catch(() => null);
             const effectiveTheirs = theirs ?? finalOnDisk;
             if (effectiveTheirs != null) {
@@ -342214,15 +341747,27 @@ var require_dist14 = __commonJS({
               }
             }
           }
+          const snapshotForFile = patch5.theirs_snapshot?.[resolvedPath] ?? patch5.theirs_snapshot?.[filePath];
+          const fileIsShared = this.sharedFiles.has(resolvedPath) || this.sharedFiles.has(filePath);
+          const useSnapshotAsPrimary = !fileIsShared && snapshotForFile != null;
           if (!ghostReconstructed) {
-            theirs = await this.applyPatchToContent(
-              base4,
-              patch5.patch_content,
-              filePath,
-              tempGit,
-              tempDir2,
-              renameSourcePath
-            );
+            if (useSnapshotAsPrimary) {
+              theirs = snapshotForFile;
+            } else {
+              theirs = await this.applyPatchToContent(
+                base4,
+                patch5.patch_content,
+                filePath,
+                tempGit,
+                tempDir2,
+                renameSourcePath
+              );
+              const reconstructionHasMarkers = theirs != null && (theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization"));
+              const baseHadMarkers = base4 != null && (base4.includes("<<<<<<< Generated") || base4.includes(">>>>>>> Your customization"));
+              if (reconstructionHasMarkers && !baseHadMarkers && snapshotForFile != null) {
+                theirs = snapshotForFile;
+              }
+            }
           }
           const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
           if (theirs) {
@@ -342581,6 +342126,600 @@ var require_dist14 = __commonJS({
       const match3 = diffLine.match(/^diff --git a\/.+ b\/(.+)$/);
       return match3 !== null && match3[1] === filePath;
     }
+    var INFRASTRUCTURE_FILES = /* @__PURE__ */ new Set([".fernignore"]);
+    function parsePatchFileHeaders(patchContent) {
+      const results = [];
+      let currentPath = null;
+      let currentIsCreate = false;
+      let currentIsDelete = false;
+      const flush3 = () => {
+        if (currentPath !== null) {
+          results.push({ path: currentPath, isCreate: currentIsCreate, isDelete: currentIsDelete });
+        }
+      };
+      for (const line of patchContent.split("\n")) {
+        if (line.startsWith("diff --git ")) {
+          flush3();
+          currentPath = null;
+          currentIsCreate = false;
+          currentIsDelete = false;
+          const match3 = line.match(/^diff --git a\/(.+?) b\/(.+?)$/);
+          if (match3) {
+            currentPath = match3[2] ?? null;
+          }
+        } else if (currentPath !== null) {
+          if (line.startsWith("new file mode ")) {
+            currentIsCreate = true;
+          } else if (line.startsWith("deleted file mode ")) {
+            currentIsDelete = true;
+          }
+        }
+      }
+      flush3();
+      return results;
+    }
+    var ReplayDetector = class {
+      git;
+      lockManager;
+      sdkOutputDir;
+      warnings = [];
+      constructor(git, lockManager, sdkOutputDir) {
+        this.git = git;
+        this.lockManager = lockManager;
+        this.sdkOutputDir = sdkOutputDir;
+      }
+      async detectNewPatches() {
+        const lock = this.lockManager.read();
+        const lastGen = this.getLastGeneration(lock);
+        if (!lastGen) {
+          return { patches: [], revertedPatchIds: [] };
+        }
+        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. Falling back to alternate detection.`
+          );
+          return this.detectPatchesViaTreeDiff(
+            lastGen,
+            /* commitKnownMissing */
+            true
+          );
+        }
+        const isAncestor = await this.git.isAncestor(lastGen.commit_sha, "HEAD");
+        if (!isAncestor) {
+          return this.detectPatchesViaMergeBase(lastGen, lock);
+        }
+        return this.detectPatchesInRange(lastGen.commit_sha, lastGen, lock);
+      }
+      /**
+       * FER-10201 — Non-linear-history detection via `merge-base(prevGen, HEAD)`.
+       *
+       * After a squash-merge of a Fern-bot PR, `lastGen.commit_sha` (the previous
+       * `[fern-generated]`) is orphaned but still in git's object database. The
+       * merge-base is the commit on main from which the bot's branch was created —
+       * a reachable ancestor of HEAD. Walking that range and classifying each
+       * commit via `isGenerationCommit` mirrors the linear path and eliminates
+       * the bug class where pipeline-driven changes (autoversion, replay,
+       * generation) get bundled as customer customizations.
+       *
+       * Falls through to the legacy composite path when no common ancestor exists
+       * (truly disjoint history — orphan branches with no shared root).
+       */
+      async detectPatchesViaMergeBase(lastGen, lock) {
+        let mergeBase = "";
+        try {
+          mergeBase = (await this.git.exec(["merge-base", lastGen.commit_sha, "HEAD"])).trim();
+        } catch {
+        }
+        if (!mergeBase) {
+          this.warnings.push(
+            `No common ancestor between previous generation ${lastGen.commit_sha.slice(0, 7)} and HEAD. Falling back to composite tree-diff detection.`
+          );
+          return this.detectPatchesViaTreeDiff(
+            lastGen,
+            /* commitKnownMissing */
+            false
+          );
+        }
+        return this.detectPatchesInRange(mergeBase, lastGen, lock);
+      }
+      /**
+       * FER-10201 — Walk `${rangeStart}..HEAD`, classify each commit, emit one
+       * `StoredPatch` per customer commit. Body shared by the linear path
+       * (rangeStart = lastGen.commit_sha) and the merge-base path.
+       *
+       * Patch `base_generation` is always `lastGen.commit_sha` — the
+       * lockfile-tracked reference the applicator uses to fetch base file
+       * content, regardless of where the walk actually started.
+       */
+      async detectPatchesInRange(rangeStart, lastGen, lock) {
+        const log4 = await this.git.exec([
+          "log",
+          "--first-parent",
+          "--format=%H%x00%an%x00%ae%x00%s",
+          `${rangeStart}..HEAD`,
+          "--",
+          this.sdkOutputDir
+        ]);
+        if (!log4.trim()) {
+          return { patches: [], revertedPatchIds: [] };
+        }
+        const commits = this.parseGitLog(log4);
+        const newPatches = [];
+        const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
+        for (const commit of commits) {
+          if (isGenerationCommit(commit)) {
+            continue;
+          }
+          if (lock.patches.find((p14) => p14.original_commit === commit.sha)) {
+            continue;
+          }
+          const parents = await this.git.getCommitParents(commit.sha);
+          if (parents.length > 1) {
+            const compositePatch = await this.createMergeCompositePatch({
+              mergeCommit: commit,
+              firstParent: parents[0],
+              lastGen,
+              lock
+            });
+            if (compositePatch) {
+              newPatches.push(compositePatch);
+            }
+            continue;
+          }
+          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;
+          }
+          let contentHash = this.computeContentHash(patchContent);
+          if (lock.patches.find((p14) => p14.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
+            continue;
+          }
+          const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
+          const allFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f5) => !INFRASTRUCTURE_FILES.has(f5)).filter((f5) => !f5.startsWith(".fern/"));
+          const sensitiveFiles = allFiles.filter((f5) => isSensitiveFile(f5));
+          const files = allFiles.filter((f5) => !isSensitiveFile(f5));
+          if (sensitiveFiles.length > 0) {
+            this.warnings.push(
+              `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveFiles.join(", ")}. These files will not be tracked by replay.`
+            );
+            if (files.length > 0) {
+              const parentSha = parents[0];
+              if (parentSha) {
+                try {
+                  patchContent = await this.git.exec(["diff", parentSha, commit.sha, "--", ...files]);
+                } catch {
+                  continue;
+                }
+                if (!patchContent.trim()) continue;
+                contentHash = this.computeContentHash(patchContent);
+              }
+            }
+          }
+          if (files.length === 0) {
+            continue;
+          }
+          const theirsSnapshot = {};
+          for (const file4 of files) {
+            if (isBinaryFile(file4)) continue;
+            const content5 = await this.git.showFile(commit.sha, file4).catch(() => null);
+            if (content5 != null) theirsSnapshot[file4] = content5;
+          }
+          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: lastGen.commit_sha,
+            files,
+            patch_content: patchContent,
+            ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {},
+            ...this.isCreationOnlyPatch(patchContent) ? { user_owned: true } : {}
+          });
+        }
+        const survivingPatches = await this.collapseNetZeroFiles(newPatches);
+        survivingPatches.reverse();
+        const revertedPatchIdSet = /* @__PURE__ */ new Set();
+        const revertIndicesToRemove = /* @__PURE__ */ new Set();
+        for (let i9 = 0; i9 < survivingPatches.length; i9++) {
+          const patch5 = survivingPatches[i9];
+          if (!isRevertCommit(patch5.original_message)) continue;
+          let body = "";
+          try {
+            body = await this.git.getCommitBody(patch5.original_commit);
+          } catch {
+          }
+          const revertedSha = parseRevertedSha(body);
+          const revertedMessage = parseRevertedMessage(patch5.original_message);
+          let matchedExisting = false;
+          if (revertedSha) {
+            const existing = lock.patches.find((p14) => p14.original_commit === revertedSha);
+            if (existing) {
+              revertedPatchIdSet.add(existing.id);
+              revertIndicesToRemove.add(i9);
+              matchedExisting = true;
+            }
+          }
+          if (!matchedExisting && revertedMessage) {
+            const existing = lock.patches.find((p14) => p14.original_message === revertedMessage);
+            if (existing) {
+              revertedPatchIdSet.add(existing.id);
+              revertIndicesToRemove.add(i9);
+              matchedExisting = true;
+            }
+          }
+          if (matchedExisting) continue;
+          let matchedNew = false;
+          if (revertedSha) {
+            const idx = survivingPatches.findIndex(
+              (p14, j7) => j7 !== i9 && !revertIndicesToRemove.has(j7) && p14.original_commit === revertedSha
+            );
+            if (idx !== -1) {
+              revertIndicesToRemove.add(i9);
+              revertIndicesToRemove.add(idx);
+              matchedNew = true;
+            }
+          }
+          if (!matchedNew && revertedMessage) {
+            const idx = survivingPatches.findIndex(
+              (p14, j7) => j7 !== i9 && !revertIndicesToRemove.has(j7) && p14.original_message === revertedMessage
+            );
+            if (idx !== -1) {
+              revertIndicesToRemove.add(i9);
+              revertIndicesToRemove.add(idx);
+            }
+          }
+          if (!matchedExisting && !matchedNew) {
+            revertIndicesToRemove.add(i9);
+          }
+        }
+        const filteredPatches = survivingPatches.filter((_7, i9) => !revertIndicesToRemove.has(i9));
+        return { patches: filteredPatches, revertedPatchIds: [...revertedPatchIdSet] };
+      }
+      /**
+       * Compute content hash for deduplication.
+       *
+       * Produces a format-agnostic hash so both `git format-patch` output
+       * (email-wrapped) and plain `git diff` output hash to the same value
+       * when the underlying diff hunks are identical.
+       *
+       * Normalization:
+       *   1. Strip email wrapper: everything before the first `diff --git` line
+       *      (From:, Subject:, Date:, diffstat, blank separators).
+       *   2. Strip `index` lines (blob SHA pairs change across rebases).
+       *   3. Strip trailing git version marker (`-- \n<version>`).
+       *
+       * This ensures content hashes match across the no-patches and normal-
+       * regeneration flows, which store formatPatch and git-diff formats
+       * respectively (FER-9850, D5-D9).
+       */
+      computeContentHash(patchContent) {
+        const lines = patchContent.split("\n");
+        const diffStart = lines.findIndex((l9) => l9.startsWith("diff --git "));
+        const relevantLines = diffStart > 0 ? lines.slice(diffStart) : lines;
+        const normalized = relevantLines.filter((line) => !line.startsWith("index ")).join("\n").replace(/\n-- \n[\d]+\.[\d]+[^\n]*\s*$/, "");
+        return `sha256:${(0, import_node_crypto7.createHash)("sha256").update(normalized).digest("hex")}`;
+      }
+      /**
+       * FER-9805 — Drop patches whose files were transiently created and then
+       * deleted within the current linear detection window, and are absent from
+       * HEAD at the end of the window.
+       *
+       * Rationale: on a merge commit, createMergeCompositePatch already diffs
+       * firstParent..mergeCommit so net-zero files never enter the composite. On
+       * linear history each commit becomes its own patch, so a file that was
+       * briefly added and later removed survives as a create+delete pair whose
+       * cumulative diff is empty. We drop such patches before they reach the
+       * lockfile.
+       *
+       * A file is "transient" when:
+       *   1. some patch in the window sets `new file mode` for it (a creation), AND
+       *   2. some patch in the window sets `deleted file mode` for it (a deletion), AND
+       *   3. it is absent from HEAD's tree.
+       *
+       * The HEAD guard (#3) prevents false positives when a file is deleted
+       * and then recreated with different content — the cumulative diff of
+       * such a pair is non-empty and must be preserved.
+       *
+       * This only drops patches whose `files` are a subset of the transient
+       * set. A partial-transient patch (one that touches a transient file
+       * alongside a persistent one) is left unmodified; surgical stripping of
+       * single files from a multi-file patch would require a follow-up that
+       * regenerates the patch content via `git format-patch -- <files>`. No
+       * current failing test exercises this, and leaving the patch intact
+       * preserves today's behaviour. TODO(FER-9805): revisit if a future
+       * adversarial test demands per-file stripping.
+       */
+      async collapseNetZeroFiles(patches) {
+        if (patches.length === 0) return patches;
+        const stateByFile = /* @__PURE__ */ new Map();
+        for (const patch5 of patches) {
+          for (const header of parsePatchFileHeaders(patch5.patch_content)) {
+            if (!header.isCreate && !header.isDelete) continue;
+            const prior = stateByFile.get(header.path) ?? { created: false, deleted: false };
+            if (header.isCreate) prior.created = true;
+            if (header.isDelete) prior.deleted = true;
+            stateByFile.set(header.path, prior);
+          }
+        }
+        let anyCandidate = false;
+        for (const state of stateByFile.values()) {
+          if (state.created && state.deleted) {
+            anyCandidate = true;
+            break;
+          }
+        }
+        if (!anyCandidate) return patches;
+        const headFiles = await this.listHeadFiles();
+        const transient = /* @__PURE__ */ new Set();
+        for (const [file4, state] of stateByFile) {
+          if (state.created && state.deleted && !headFiles.has(file4)) {
+            transient.add(file4);
+          }
+        }
+        if (transient.size === 0) return patches;
+        return patches.filter((patch5) => !patch5.files.every((f5) => transient.has(f5)));
+      }
+      /**
+       * List every tracked path at HEAD (one `git ls-tree -r` invocation).
+       * Returns an empty Set if HEAD is unborn or the invocation fails — the
+       * caller then treats every candidate as "not in HEAD" and may collapse
+       * more aggressively. On typical SDK repos this is a single sub-10ms call.
+       */
+      async listHeadFiles() {
+        try {
+          const out = await this.git.exec(["ls-tree", "-r", "--name-only", "HEAD"]);
+          return new Set(out.split("\n").map((l9) => l9.trim()).filter(Boolean));
+        } catch {
+          return /* @__PURE__ */ new Set();
+        }
+      }
+      /**
+       * Create a single composite patch for a merge commit by diffing the merge
+       * commit against its first parent. This captures the net change of the
+       * entire merged branch as one patch, eliminating accumulator chaining and
+       * zero-net-change ghost conflicts.
+       */
+      async createMergeCompositePatch(input3) {
+        const { mergeCommit, firstParent, lastGen, lock } = input3;
+        const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
+        const filesOutput = await this.git.exec([
+          "diff",
+          "--name-only",
+          firstParent,
+          mergeCommit.sha
+        ]);
+        const allMergeFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f5) => !INFRASTRUCTURE_FILES.has(f5)).filter((f5) => !f5.startsWith(".fern/"));
+        const sensitiveMergeFiles = allMergeFiles.filter((f5) => isSensitiveFile(f5));
+        const files = allMergeFiles.filter((f5) => !isSensitiveFile(f5));
+        if (sensitiveMergeFiles.length > 0) {
+          this.warnings.push(
+            `Sensitive file(s) excluded from merge patch for commit ${mergeCommit.sha.slice(0, 7)}: ${sensitiveMergeFiles.join(", ")}. These files will not be tracked by replay.`
+          );
+        }
+        if (files.length === 0) return null;
+        const diff2 = await this.git.exec([
+          "diff",
+          firstParent,
+          mergeCommit.sha,
+          "--",
+          ...files
+        ]);
+        if (!diff2.trim()) return null;
+        const contentHash = this.computeContentHash(diff2);
+        if (lock.patches.some((p14) => p14.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
+          return null;
+        }
+        const theirsSnapshot = {};
+        for (const file4 of files) {
+          if (isBinaryFile(file4)) continue;
+          const content5 = await this.git.showFile(mergeCommit.sha, file4).catch(() => null);
+          if (content5 != null) theirsSnapshot[file4] = content5;
+        }
+        return {
+          id: `patch-merge-${mergeCommit.sha.slice(0, 8)}`,
+          content_hash: contentHash,
+          original_commit: mergeCommit.sha,
+          original_message: mergeCommit.message,
+          original_author: `${mergeCommit.authorName} <${mergeCommit.authorEmail}>`,
+          base_generation: lastGen.commit_sha,
+          files,
+          patch_content: diff2,
+          ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {},
+          ...this.isCreationOnlyPatch(diff2) ? { user_owned: true } : {}
+        };
+      }
+      /**
+       * Detect patches via tree diff for non-linear history. Returns a composite patch.
+       * 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, 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 allTreeFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f5) => !INFRASTRUCTURE_FILES.has(f5)).filter((f5) => !f5.startsWith(".fern/"));
+        const sensitiveTreeFiles = allTreeFiles.filter((f5) => isSensitiveFile(f5));
+        const files = allTreeFiles.filter((f5) => !isSensitiveFile(f5));
+        if (sensitiveTreeFiles.length > 0) {
+          this.warnings.push(
+            `Sensitive file(s) excluded from composite patch: ${sensitiveTreeFiles.join(", ")}. These files will not be tracked by replay.`
+          );
+        }
+        if (files.length === 0) return { patches: [], revertedPatchIds: [] };
+        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();
+        if (lock.patches.some((p14) => p14.content_hash === contentHash) || (lock.forgotten_hashes ?? []).includes(contentHash)) {
+          return { patches: [], revertedPatchIds: [] };
+        }
+        const headSha = (await this.git.exec(["rev-parse", "HEAD"])).trim();
+        const theirsSnapshot = {};
+        for (const file4 of files) {
+          if (isBinaryFile(file4)) continue;
+          const content5 = await this.git.showFile("HEAD", file4).catch(() => null);
+          if (content5 != null) theirsSnapshot[file4] = content5;
+        }
+        const compositePatch = {
+          id: `patch-composite-${headSha.slice(0, 8)}`,
+          content_hash: contentHash,
+          original_commit: headSha,
+          original_message: "Customer customizations (composite)",
+          original_author: "composite",
+          // 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,
+          ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {},
+          ...this.isCreationOnlyPatch(diff2) ? { user_owned: true } : {}
+        };
+        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((p14) => p14.content_hash));
+        const existingCommits = new Set(lock.patches.map((p14) => p14.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;
+          }
+          let 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 allScanFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f5) => !INFRASTRUCTURE_FILES.has(f5));
+          const sensitiveScanFiles = allScanFiles.filter((f5) => isSensitiveFile(f5));
+          const files = allScanFiles.filter((f5) => !isSensitiveFile(f5));
+          if (sensitiveScanFiles.length > 0) {
+            this.warnings.push(
+              `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveScanFiles.join(", ")}. These files will not be tracked by replay.`
+            );
+            if (files.length > 0) {
+              if (parents.length === 0) {
+                continue;
+              }
+              try {
+                patchContent = await this.git.exec(["diff", parents[0], commit.sha, "--", ...files]);
+              } catch {
+                continue;
+              }
+              if (!patchContent.trim()) continue;
+              contentHash = this.computeContentHash(patchContent);
+            }
+          }
+          if (files.length === 0) {
+            continue;
+          }
+          if (parents.length === 0) {
+            continue;
+          }
+          const parentSha = parents[0];
+          const theirsSnapshot = {};
+          for (const file4 of files) {
+            if (isBinaryFile(file4)) continue;
+            const content5 = await this.git.showFile(commit.sha, file4).catch(() => null);
+            if (content5 != null) theirsSnapshot[file4] = content5;
+          }
+          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,
+            ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {}
+          });
+        }
+        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((l9) => l9.startsWith("--- "));
+        if (diffOldHeaders.length === 0) {
+          return false;
+        }
+        return diffOldHeaders.every((l9) => l9 === "--- /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");
+          return { sha, authorName, authorEmail, message };
+        });
+      }
+      getLastGeneration(lock) {
+        return lock.generations.find((g8) => g8.commit_sha === lock.current_generation);
+      }
+    };
     var ReplayCommitter = class {
       git;
       outputDir;
@@ -342683,7 +342822,8 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
       }
     };
     var import_node_fs210 = require("fs");
-    var import_node_path43 = require("path");
+    var import_promises410 = require("fs/promises");
+    var import_node_path52 = require("path");
     var import_minimatch22 = require_commonjs3();
     init_GitClient();
     var import_promises210 = require("fs/promises");
@@ -342740,13 +342880,13 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         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;
+          let ctx = 0, rm42 = 0, add = 0;
           for (const ln10 of h4.lines) {
             if (ln10.type === "context") ctx++;
-            else if (ln10.type === "remove") rm32++;
+            else if (ln10.type === "remove") rm42++;
             else if (ln10.type === "add") add++;
           }
-          return ctx + rm32 === h4.oldCount && ctx + add === h4.newCount;
+          return ctx + rm42 === h4.oldCount && ctx + add === h4.newCount;
         });
         if (hunks.length === 0) {
           if (hunksRaw.length > 0) unlocatableFiles.push(file4);
@@ -343454,19 +343594,14 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         existingPatches = this.lockManager.getPatches();
         const seenHashes = /* @__PURE__ */ new Map();
         for (const p14 of existingPatches) {
-          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).`
-              );
-            }
+          const priorPatchId = seenHashes.get(p14.content_hash);
+          if (priorPatchId !== void 0) {
+            this.lockManager.removePatch(p14.id);
+            this.warnings.push(
+              `Consolidated patch ${p14.id} (commit ${(p14.original_commit || "<missing>").slice(0, 7)}) into prior patch ${priorPatchId}: byte-identical patch_content. Per-commit attribution preserved in git log; lockfile collapsed to avoid duplicate-apply corruption on next regen.`
+            );
           } else {
-            seenHashes.set(p14.content_hash, p14.original_commit);
+            seenHashes.set(p14.content_hash, p14.id);
           }
         }
         existingPatches = this.lockManager.getPatches();
@@ -343647,17 +343782,27 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
             if (allUserOwned && patch5.files.length > 0) {
               const baseChanged = patch5.base_generation !== currentGenSha;
               const userDiff = await this.git.exec(["diff", currentGenSha, "--", ...patch5.files]).catch(() => null);
+              let userDiffSnapshot = null;
               if (userDiff != null && userDiff.trim()) {
                 const newHash = this.detector.computeContentHash(userDiff);
                 patch5.patch_content = userDiff;
                 patch5.content_hash = newHash;
+                const snap = await this.readSnapshotFromDisk(patch5.files);
+                if (Object.keys(snap).length > 0) {
+                  userDiffSnapshot = snap;
+                  patch5.theirs_snapshot = snap;
+                }
               }
               patch5.base_generation = currentGenSha;
               try {
                 this.lockManager.updatePatch(patch5.id, {
                   base_generation: currentGenSha,
                   ...!patch5.user_owned ? { user_owned: true } : {},
-                  ...userDiff != null && userDiff.trim() ? { patch_content: patch5.patch_content, content_hash: patch5.content_hash } : {}
+                  ...userDiff != null && userDiff.trim() ? {
+                    patch_content: patch5.patch_content,
+                    content_hash: patch5.content_hash,
+                    ...userDiffSnapshot != null && Object.keys(userDiffSnapshot).length > 0 ? { theirs_snapshot: userDiffSnapshot } : {}
+                  } : {}
                 });
               } catch {
               }
@@ -343705,30 +343850,34 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
               continue;
             }
             const newContentHash = this.detector.computeContentHash(diff2);
-            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;
+            const priorPatchId = seenContentHashes.get(newContentHash);
+            if (priorPatchId !== void 0) {
+              this.lockManager.removePatch(patch5.id);
+              absorbedPatchIds.add(patch5.id);
+              absorbed++;
+              if (priorPatchId !== patch5.id) {
+                this.warnings.push(
+                  `Consolidated patch ${patch5.id} (commit ${(patch5.original_commit || "<missing>").slice(0, 7)}) into prior patch ${priorPatchId}: byte-identical patch_content after rebase. Per-commit attribution preserved in git log.`
+                );
               }
-              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).`
-              );
+              continue;
             } else {
-              seenContentHashes.set(newContentHash, patch5.original_commit);
+              seenContentHashes.set(newContentHash, patch5.id);
             }
             patch5.base_generation = currentGenSha;
             patch5.patch_content = diff2;
             patch5.content_hash = newContentHash;
+            const snapshot = await this.readSnapshotFromDisk(patch5.files);
+            const snapshotIsNonEmpty = Object.keys(snapshot).length > 0;
+            if (snapshotIsNonEmpty) {
+              patch5.theirs_snapshot = snapshot;
+            }
             try {
               this.lockManager.updatePatch(patch5.id, {
                 base_generation: currentGenSha,
                 patch_content: diff2,
-                content_hash: newContentHash
+                content_hash: newContentHash,
+                ...snapshotIsNonEmpty ? { theirs_snapshot: snapshot } : {}
               });
             } catch {
             }
@@ -343738,6 +343887,112 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         }
         return { absorbed, repointed, contentRebased, keptAsUserOwned, absorbedPatchIds };
       }
+      /**
+       * Read THEIRS snapshot (post-customer-edit content) for a list of files
+       * from the working tree on disk. Used by `rebasePatches` after a clean
+       * apply — disk = correctly-merged customer state at the new generation.
+       * Skips binary files (matches `mergeFile`/`populateAccumulatorForPatch`
+       * policy — binary content as `utf-8` is lossy and snapshots of it would
+       * never be used during apply anyway).
+       */
+      async readSnapshotFromDisk(files) {
+        const snapshot = {};
+        for (const file4 of files) {
+          if (isBinaryFile(file4)) continue;
+          try {
+            const content5 = await (0, import_promises410.readFile)((0, import_node_path52.join)(this.outputDir, file4), "utf-8");
+            snapshot[file4] = content5;
+          } catch {
+          }
+        }
+        return snapshot;
+      }
+      /**
+       * Read THEIRS snapshot from a git tree-ish (commit, branch, or tree).
+       * Used when the diff that produced `patch_content` was relative to that
+       * tree (e.g., `git diff currentGen HEAD --` → snapshot from HEAD).
+       * Skips binary files.
+       */
+      async readSnapshotFromTree(treeRef, files) {
+        const snapshot = {};
+        for (const file4 of files) {
+          if (isBinaryFile(file4)) continue;
+          const content5 = await this.git.showFile(treeRef, file4).catch(() => null);
+          if (content5 != null) snapshot[file4] = content5;
+        }
+        return snapshot;
+      }
+      /**
+       * One-shot auto-migration: backfill `theirs_snapshot` on existing
+       * patches that predate the snapshot encoding. Computes the snapshot by
+       * applying the patch's `patch_content` to its `base_generation` tree —
+       * yielding the patch's INDIVIDUAL contribution.
+       *
+       * **Skips patches sharing files with other patches.** HEAD's content
+       * for a file shared by N patches is cumulative across all of them, so
+       * a HEAD-fallback would falsely encode other patches' contributions
+       * into one patch's snapshot — breaking FER-9525 cross-patch isolation
+       * if the snapshot fallback later fires. Per-patch snapshots only
+       * make sense when the patch owns its file. Multi-patch-same-file
+       * legacy lockfiles keep using line-anchored reconstruction (the
+       * existing path); they're no worse than pre-upgrade.
+       *
+       * **Does not fall back to HEAD when BASE-reconstruction fails.** Same
+       * reason — HEAD content can be cumulative. Patches whose
+       * reconstruction fails just don't get a snapshot; legacy paths
+       * (PR #73's by-association gate, accumulator fallback) handle them.
+       *
+       * Skips patches that already have a snapshot.
+       */
+      async migratePatchesToSnapshot(patches) {
+        const { applyPatchToContent: applyPatchToContent2 } = await Promise.resolve().then(() => (init_PatchApplyTheirs(), PatchApplyTheirs_exports));
+        const fileFreq = /* @__PURE__ */ new Map();
+        for (const p14 of patches) {
+          for (const f5 of p14.files) {
+            fileFreq.set(f5, (fileFreq.get(f5) ?? 0) + 1);
+          }
+        }
+        let migrated = 0;
+        let skipped = 0;
+        for (const patch5 of patches) {
+          if (patch5.theirs_snapshot != null) continue;
+          const sharesAnyFile = patch5.files.some((f5) => (fileFreq.get(f5) ?? 0) > 1);
+          if (sharesAnyFile) {
+            skipped++;
+            continue;
+          }
+          const snapshot = {};
+          for (const file4 of patch5.files) {
+            if (isBinaryFile(file4)) continue;
+            try {
+              const base4 = await this.git.showFile(patch5.base_generation, file4).catch(() => null);
+              if (base4 != null) {
+                const content5 = await applyPatchToContent2(base4, patch5.patch_content, file4);
+                if (content5 != null) snapshot[file4] = content5;
+              }
+            } catch {
+            }
+          }
+          if (Object.keys(snapshot).length > 0) {
+            patch5.theirs_snapshot = snapshot;
+            try {
+              this.lockManager.updatePatch(patch5.id, { theirs_snapshot: snapshot });
+              migrated++;
+            } catch {
+            }
+          }
+        }
+        if (migrated > 0) {
+          this.warnings.push(
+            `Migrated ${migrated} patch(es) to snapshot encoding. Future regens use 3-way merge with stored THEIRS, robust to generator structural changes.`
+          );
+        }
+        if (skipped > 0) {
+          this.warnings.push(
+            `Skipped snapshot migration for ${skipped} patch(es) sharing files with other patches. These continue to use line-anchored reconstruction (the existing path).`
+          );
+        }
+      }
       /**
        * Determine whether `file` is user-owned (never produced by the generator).
        *
@@ -343858,6 +344113,20 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
           this.lockManager.clearReplaySkippedAt();
           return { conflictResolved: 0, conflictAbsorbed: 0, contentRefreshed: 0 };
         }
+        await this.migratePatchesToSnapshot(patches);
+        const headMessage = await this.git.exec(["log", "-1", "--format=%s%n%aN%n%ae", "HEAD"]).catch(() => "");
+        const [headMsgLine, headAuthorName, headAuthorEmail] = headMessage.split("\n");
+        const headIsGeneration = headMsgLine ? isGenerationCommit({
+          sha: "HEAD",
+          authorName: headAuthorName ?? "",
+          authorEmail: headAuthorEmail ?? "",
+          message: headMsgLine
+        }) : false;
+        const headParentChangedFiles = async (patchFiles) => {
+          if (patchFiles.length === 0) return /* @__PURE__ */ new Set();
+          const diff2 = await this.git.exec(["diff", "--name-only", "HEAD~1", "HEAD", "--", ...patchFiles]).catch(() => "");
+          return new Set(diff2.trim().split("\n").filter(Boolean));
+        };
         let conflictResolved = 0;
         let conflictAbsorbed = 0;
         let contentRefreshed = 0;
@@ -343894,6 +344163,13 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
             delete patch5.status;
             continue;
           }
+          if (headIsGeneration) {
+            const parentChangedFiles = await headParentChangedFiles(patch5.files);
+            const headTouchedSource = patch5.files.some((f5) => parentChangedFiles.has(f5));
+            if (headTouchedSource) {
+              continue;
+            }
+          }
           if (patch5.base_generation === currentGen) {
             try {
               const ppResult = await computePerPatchDiffWithFallback(
@@ -343930,10 +344206,12 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
                 if (newFiles.length === 0) {
                   this.lockManager.removePatch(patch5.id);
                 } else {
+                  const snapshot = await this.readSnapshotFromTree("HEAD", newFiles);
                   this.lockManager.updatePatch(patch5.id, {
                     patch_content: diff2,
                     content_hash: newContentHash,
-                    files: newFiles
+                    files: newFiles,
+                    ...Object.keys(snapshot).length > 0 ? { theirs_snapshot: snapshot } : {}
                   });
                 }
                 contentRefreshed++;
@@ -343966,10 +344244,12 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
               continue;
             }
             const newContentHash = this.detector.computeContentHash(diff2);
+            const snapshot = await this.readSnapshotFromTree("HEAD", patch5.files);
             this.lockManager.updatePatch(patch5.id, {
               base_generation: currentGen,
               patch_content: diff2,
-              content_hash: newContentHash
+              content_hash: newContentHash,
+              ...Object.keys(snapshot).length > 0 ? { theirs_snapshot: snapshot } : {}
             });
             conflictResolved++;
           } catch {
@@ -344012,7 +344292,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
           if (result.status !== "conflict" || !result.fileResults) continue;
           for (const fileResult of result.fileResults) {
             if (fileResult.status !== "conflict") continue;
-            const filePath = (0, import_node_path43.join)(this.outputDir, fileResult.file);
+            const filePath = (0, import_node_path52.join)(this.outputDir, fileResult.file);
             try {
               const content5 = (0, import_node_fs210.readFileSync)(filePath, "utf-8");
               const stripped = stripConflictMarkers(content5);
@@ -344042,7 +344322,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         }
       }
       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_fs210.existsSync)(fernignorePath)) return [];
         return (0, import_node_fs210.readFileSync)(fernignorePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
       }
@@ -344119,7 +344399,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
     }
     var import_node_crypto22 = require("crypto");
     var import_node_fs33 = require("fs");
-    var import_node_path52 = require("path");
+    var import_node_path62 = require("path");
     var import_minimatch32 = require_commonjs3();
     var import_yaml22 = require_dist9();
     var FernignoreMigrator = class {
@@ -344132,10 +344412,10 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         this.outputDir = outputDir;
       }
       fernignoreExists() {
-        return (0, import_node_fs33.existsSync)((0, import_node_path52.join)(this.outputDir, ".fernignore"));
+        return (0, import_node_fs33.existsSync)((0, import_node_path62.join)(this.outputDir, ".fernignore"));
       }
       readFernignorePatterns() {
-        const fernignorePath = (0, import_node_path52.join)(this.outputDir, ".fernignore");
+        const fernignorePath = (0, import_node_path62.join)(this.outputDir, ".fernignore");
         if (!(0, import_node_fs33.existsSync)(fernignorePath)) {
           return [];
         }
@@ -344187,6 +344467,12 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
             if (patchFiles.length > 0) {
               const patchContent = diffParts.join("\n");
               const contentHash = `sha256:${(0, import_node_crypto22.createHash)("sha256").update(patchContent).digest("hex")}`;
+              const theirsSnapshot = {};
+              for (const filePath of patchFiles) {
+                if (isBinaryFile(filePath)) continue;
+                const c5 = this.readFileContent(filePath);
+                if (c5 != null) theirsSnapshot[filePath] = c5;
+              }
               syntheticPatches.push({
                 id: `patch-fernignore-${(0, import_node_crypto22.createHash)("sha256").update(pattern).digest("hex").slice(0, 8)}`,
                 content_hash: contentHash,
@@ -344196,6 +344482,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
                 base_generation: currentGen.commit_sha,
                 files: patchFiles,
                 patch_content: patchContent,
+                ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {},
                 // 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
@@ -344237,7 +344524,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         return results;
       }
       readFileContent(filePath) {
-        const fullPath = (0, import_node_path52.join)(this.outputDir, filePath);
+        const fullPath = (0, import_node_path62.join)(this.outputDir, filePath);
         if (!(0, import_node_fs33.existsSync)(fullPath)) {
           return null;
         }
@@ -344302,7 +344589,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         };
       }
       movePatternsToReplayYml(patterns) {
-        const replayYmlPath = (0, import_node_path52.join)(this.outputDir, ".fern", "replay.yml");
+        const replayYmlPath = (0, import_node_path62.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");
@@ -344311,7 +344598,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         const existing = config5.exclude ?? [];
         const merged = [.../* @__PURE__ */ new Set([...existing, ...patterns])];
         config5.exclude = merged;
-        const dir = (0, import_node_path52.dirname)(replayYmlPath);
+        const dir = (0, import_node_path62.dirname)(replayYmlPath);
         if (!(0, import_node_fs33.existsSync)(dir)) {
           (0, import_node_fs33.mkdirSync)(dir, { recursive: true });
         }
@@ -344320,7 +344607,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
     };
     var import_node_crypto32 = require("crypto");
     var import_node_fs42 = require("fs");
-    var import_node_path62 = require("path");
+    var import_node_path72 = require("path");
     init_GitClient();
     async function bootstrap(outputDir, options2) {
       const git = new GitClient(outputDir);
@@ -344487,7 +344774,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
     }
     var REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml", ".gitattributes"];
     function ensureFernignoreEntries(outputDir) {
-      const fernignorePath = (0, import_node_path62.join)(outputDir, ".fernignore");
+      const fernignorePath = (0, import_node_path72.join)(outputDir, ".fernignore");
       let content5 = "";
       if ((0, import_node_fs42.existsSync)(fernignorePath)) {
         content5 = (0, import_node_fs42.readFileSync)(fernignorePath, "utf-8");
@@ -344511,7 +344798,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
     }
     var GITATTRIBUTES_ENTRIES = [".fern/replay.lock linguist-generated=true"];
     function ensureGitattributesEntries(outputDir) {
-      const gitattributesPath = (0, import_node_path62.join)(outputDir, ".gitattributes");
+      const gitattributesPath = (0, import_node_path72.join)(outputDir, ".gitattributes");
       let content5 = "";
       if ((0, import_node_fs42.existsSync)(gitattributesPath)) {
         content5 = (0, import_node_fs42.readFileSync)(gitattributesPath, "utf-8");
@@ -344703,8 +344990,8 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         nothingToReset: false
       };
     }
-    var import_promises310 = require("fs/promises");
-    var import_node_path72 = require("path");
+    var import_promises510 = require("fs/promises");
+    var import_node_path82 = require("path");
     init_GitClient();
     async function resolve15(outputDir, options2) {
       const lockManager = new LockfileManager(outputDir);
@@ -344748,36 +345035,78 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         const detector = new ReplayDetector(git, lockManager, outputDir);
         const warnings = [];
         let patchesResolved = 0;
+        const pass1 = [];
         for (const patch5 of patchesToCommit) {
           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),
+            (f5) => (0, import_promises510.readFile)((0, import_node_path82.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`
             );
+            pass1.push({ kind: "skip" });
             continue;
           }
           const diff2 = result.diff;
           if (!diff2.trim()) {
+            pass1.push({ kind: "revert" });
+            continue;
+          }
+          const hash5 = detector.computeContentHash(diff2);
+          pass1.push({
+            kind: "apply",
+            diff: diff2,
+            hash: hash5,
+            hadFallback: result.hadFallback,
+            fallbackFiles: result.fallbackFiles
+          });
+        }
+        const lastIndexByHash = /* @__PURE__ */ new Map();
+        for (let i9 = 0; i9 < pass1.length; i9++) {
+          const r5 = pass1[i9];
+          if (r5.kind === "apply") lastIndexByHash.set(r5.hash, i9);
+        }
+        for (let i9 = 0; i9 < patchesToCommit.length; i9++) {
+          const patch5 = patchesToCommit[i9];
+          const r5 = pass1[i9];
+          if (r5.kind === "skip") continue;
+          if (r5.kind === "revert") {
+            lockManager.removePatch(patch5.id);
+            continue;
+          }
+          if (lastIndexByHash.get(r5.hash) !== i9) {
+            const canonicalIdx = lastIndexByHash.get(r5.hash);
+            const canonical = patchesToCommit[canonicalIdx];
             lockManager.removePatch(patch5.id);
+            warnings.push(
+              `Consolidated patch ${patch5.id} (commit ${(patch5.original_commit || "<missing>").slice(0, 7)}) into patch ${canonical.id} (commit ${(canonical.original_commit || "<missing>").slice(0, 7)}): byte-identical patch_content after resolution. Per-commit attribution preserved in git log; lockfile collapsed to avoid duplicate-apply corruption on next regen.`
+            );
             continue;
           }
-          if (result.hadFallback) {
+          if (r5.hadFallback) {
             warnings.push(
-              `Patch ${patch5.id}: ${result.fallbackFiles.join(", ")} could not be anchored; cumulative-diff fallback applied for those files`
+              `Patch ${patch5.id}: ${r5.fallbackFiles.join(", ")} could not be anchored; cumulative-diff fallback applied for those files`
             );
           }
-          const newContentHash = detector.computeContentHash(diff2);
-          const changedFiles = result.hadFallback ? await getChangedFiles(git, currentGen, patch5.files) : extractFilesFromDiff(diff2);
+          const changedFiles = r5.hadFallback ? await getChangedFiles(git, currentGen, patch5.files) : extractFilesFromDiff(r5.diff);
+          const filesForSnapshot = changedFiles.length > 0 ? changedFiles : patch5.files;
+          const theirsSnapshot = {};
+          for (const file4 of filesForSnapshot) {
+            if (isBinaryFile(file4)) continue;
+            const content5 = await (0, import_promises510.readFile)((0, import_node_path82.join)(outputDir, file4), "utf-8").catch(() => null);
+            if (content5 != null) {
+              theirsSnapshot[file4] = content5;
+            }
+          }
           lockManager.markPatchResolved(patch5.id, {
-            patch_content: diff2,
-            content_hash: newContentHash,
+            patch_content: r5.diff,
+            content_hash: r5.hash,
             base_generation: currentGen,
-            files: changedFiles.length > 0 ? changedFiles : patch5.files
+            files: filesForSnapshot,
+            ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {}
           });
           patchesResolved++;
         }
@@ -531075,6 +531404,9 @@ function isAdditionalPropertiesAny(additionalProperties7, options2) {
   if (typeof additionalProperties7 === "boolean") {
     return additionalProperties7;
   }
+  if (typeof additionalProperties7 !== "object" || additionalProperties7 === null) {
+    return true;
+  }
   if (isReferenceObject(additionalProperties7)) {
     return false;
   }
@@ -603250,6 +603582,9 @@ var ExampleConverter = class _ExampleConverter extends AbstractConverter {
    * These schemas are used in allOf compositions to add constraints to the merged schema.
    */
   isConstraintOnlySchema(schema2) {
+    if (typeof schema2 !== "object" || schema2 === null) {
+      return false;
+    }
     if (schema2.type !== void 0 || schema2.properties !== void 0 || schema2.allOf !== void 0 || schema2.oneOf !== void 0 || schema2.anyOf !== void 0 || "items" in schema2 || schema2.additionalProperties !== void 0 || schema2.enum !== void 0 || schema2.const !== void 0) {
       return false;
     }
@@ -604478,7 +604813,7 @@ var OneOfSchemaConverter = class extends AbstractConverter {
     if (schemaArray == null) {
       return void 0;
     }
-    const withoutNull = schemaArray.filter((subSchema) => !("type" in subSchema && subSchema.type === "null"));
+    const withoutNull = schemaArray.filter((subSchema) => !(typeof subSchema === "object" && subSchema !== null && "type" in subSchema && subSchema.type === "null"));
     if (withoutNull.length === 0) {
       this.context.errorCollector.collect({
         message: `Received ${schemaType} schema with no valid non-null types`,
@@ -605406,7 +605741,7 @@ var SchemaOrReferenceConverter = class extends AbstractConverter {
       return void 0;
     }
     const refElements = this.schemaOrReference.allOf.filter((s9) => this.context.isReferenceObject(s9));
-    const inlineElements = this.schemaOrReference.allOf.filter((s9) => !this.context.isReferenceObject(s9));
+    const inlineElements = this.schemaOrReference.allOf.filter((s9) => typeof s9 === "object" && s9 !== null && !this.context.isReferenceObject(s9));
     const singleRef = refElements.length === 1 ? refElements[0] : void 0;
     if (singleRef != null && inlineElements.every((s9) => !s9.properties && !s9.enum && !s9.oneOf && !s9.anyOf && !s9.allOf && !s9.format && !("items" in s9)) && !inlineElements.some((s9) => s9.type === "null" || Array.isArray(s9.type) && s9.type.includes("null"))) {
       const resolved = this.context.resolveMaybeReference({
@@ -622052,7 +622387,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "5.4.0",
+          version: "5.4.1",
           usingAccessToken: true
         }
       });
@@ -622106,7 +622441,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "5.4.0",
+        version: "5.4.1",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -829125,6 +829460,39 @@ function collectPathnamesToCheck(content5, { absoluteFilepath, instanceUrls }) {
 
 // ../yaml/docs-validator/lib/rules/valid-markdown-link/valid-markdown-link.js
 var NOOP_CONTEXT2 = createMockTaskContext({ logger: createLogger(noop2) });
+function createDocsResolverValidationContext() {
+  const base4 = createMockTaskContext({ logger: createLogger(noop2) });
+  return {
+    ...base4,
+    failAndThrow: (message, error50, _options) => {
+      const messageParts = [];
+      if (message != null) {
+        messageParts.push(message);
+      }
+      if (error50 instanceof Error) {
+        messageParts.push(error50.message);
+      } else if (error50 != null) {
+        messageParts.push(JSON.stringify(error50));
+      }
+      const combined = messageParts.length > 0 ? messageParts.join(": ") : "Docs validation failed";
+      throw new Error(combined);
+    },
+    failWithoutThrowing: (message, error50, _options) => {
+      const messageParts = [];
+      if (message != null) {
+        messageParts.push(message);
+      }
+      if (error50 instanceof Error) {
+        messageParts.push(error50.message);
+      } else if (error50 != null) {
+        messageParts.push(JSON.stringify(error50));
+      }
+      if (messageParts.length > 0) {
+        base4.logger.error(messageParts.join(": "));
+      }
+    }
+  };
+}
 function isV1RootNode2(value2) {
   return "type" in value2 && value2.type === "root";
 }
@@ -829139,7 +829507,7 @@ var ValidMarkdownLinks = {
       docsWorkspace: workspace,
       ossWorkspaces,
       apiWorkspaces,
-      taskContext: NOOP_CONTEXT2,
+      taskContext: createDocsResolverValidationContext(),
       editThisPage: void 0,
       uploadFiles: void 0,
       registerApi: void 0,
@@ -830363,12 +830731,37 @@ async function runRulesOnDocsWorkspace({ workspace, rules: selectedRules, contex
   context3.logger.debug(`Initial memory usage: RSS=${(startMemory.rss / 1024 / 1024).toFixed(2)}MB, Heap=${(startMemory.heapUsed / 1024 / 1024).toFixed(2)}MB`);
   const violations = [];
   const ruleCreationStart = performance.now();
-  const allRulesWithVisitors = await Promise.all(rules.map(async (rule) => ({
-    ruleName: rule.name,
-    visitor: await rule.create({ workspace, apiWorkspaces, ossWorkspaces, logger: context3.logger })
-  })));
+  const ruleCreationResults = await Promise.all(rules.map(async (rule) => {
+    try {
+      const visitor = await rule.create({
+        workspace,
+        apiWorkspaces,
+        ossWorkspaces,
+        logger: context3.logger
+      });
+      return { ruleName: rule.name, visitor };
+    } catch (error50) {
+      return { ruleName: rule.name, error: error50 };
+    }
+  }));
+  const allRulesWithVisitors = [];
+  for (const result of ruleCreationResults) {
+    if ("error" in result) {
+      const message = result.error instanceof Error ? result.error.message : String(result.error);
+      violations.push({
+        name: result.ruleName,
+        severity: "fatal",
+        relativeFilepath: RelativeFilePath2.of(DOCS_CONFIGURATION_FILENAME),
+        nodePath: [],
+        message: `Rule "${result.ruleName}" failed to initialize: ${message}`
+      });
+      context3.logger.debug(`Rule "${result.ruleName}" failed to initialize: ${result.error instanceof Error ? result.error.stack ?? result.error.message : String(result.error)}`);
+    } else {
+      allRulesWithVisitors.push(result);
+    }
+  }
   const ruleCreationTime = performance.now() - ruleCreationStart;
-  context3.logger.debug(`Created ${rules.length} rule visitors in ${ruleCreationTime.toFixed(0)}ms`);
+  context3.logger.debug(`Created ${allRulesWithVisitors.length} rule visitors in ${ruleCreationTime.toFixed(0)}ms (${rules.length - allRulesWithVisitors.length} failed to initialize)`);
   const astVisitor = createDocsConfigFileAstVisitorForRules({
     relativeFilepath: RelativeFilePath2.of(DOCS_CONFIGURATION_FILENAME),
     allRulesWithVisitors,
@@ -834386,7 +834779,7 @@ var LOCAL_STORAGE_FOLDER4 = ".fern-dev";
 var LOGS_FOLDER_NAME = "logs";
 var MAX_LOGS_DIR_SIZE_BYTES = 100 * 1024 * 1024;
 function getCliSource() {
-  const version7 = "5.4.0";
+  const version7 = "5.4.1";
   return `cli@${version7}`;
 }
 var DebugLogger = class {
@@ -846848,7 +847241,7 @@ var LegacyDocsPublisher = class {
         previewId,
         disableTemplates: void 0,
         skipUpload,
-        cliVersion: "5.4.0",
+        cliVersion: "5.4.1",
         loginCommand: "fern auth login"
       });
       if (taskContext.getResult() === TaskResult.Failure) {
@@ -921180,7 +921573,7 @@ var CliContext = class _CliContext {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "5.4.0";
+    return "5.4.1";
   }
   getCliName() {
     if (false) {