@fern-api/generator-cli 0.9.27 → 0.9.29

package/dist/cli.js

@@ -7031,18 +7031,18 @@ var require_build3 = __commonJS({
 var require_sync = __commonJS({
   "../../node_modules/.pnpm/escalade@3.2.0/node_modules/escalade/sync/index.js"(exports2, module2) {
     "use strict";
-    var { dirname: dirname5, resolve: resolve8 } = require("path");
+    var { dirname: dirname6, resolve: resolve8 } = require("path");
     var { readdirSync: readdirSync2, statSync: statSync4 } = require("fs");
     module2.exports = function(start, callback) {
       let dir = resolve8(".", start);
       let tmp4, stats = statSync4(dir);
       if (!stats.isDirectory()) {
-        dir = dirname5(dir);
+        dir = dirname6(dir);
       }
       while (true) {
         tmp4 = callback(dir, readdirSync2(dir));
         if (tmp4) return resolve8(dir, tmp4);
-        dir = dirname5(tmp4 = dir);
+        dir = dirname6(tmp4 = dir);
         if (tmp4 === dir) break;
       }
     };
@@ -7078,9 +7078,9 @@ var require_require_directory = __commonJS({
   "../../node_modules/.pnpm/require-directory@2.1.1/node_modules/require-directory/index.js"(exports2, module2) {
     "use strict";
     var fs3 = require("fs");
-    var join16 = require("path").join;
+    var join17 = require("path").join;
     var resolve8 = require("path").resolve;
-    var dirname5 = require("path").dirname;
+    var dirname6 = require("path").dirname;
     var defaultOptions2 = {
       extensions: ["js", "json", "coffee"],
       recurse: true,
@@ -7113,9 +7113,9 @@ var require_require_directory = __commonJS({
           options[prop] = defaultOptions2[prop];
         }
       }
-      path5 = !path5 ? dirname5(m.filename) : resolve8(dirname5(m.filename), path5);
+      path5 = !path5 ? dirname6(m.filename) : resolve8(dirname6(m.filename), path5);
       fs3.readdirSync(path5).forEach(function(filename) {
-        var joined = join16(path5, filename), files, key, obj;
+        var joined = join17(path5, filename), files, key, obj;
         if (fs3.statSync(joined).isDirectory() && options.recurse) {
           files = requireDirectory(m, joined, options);
           if (Object.keys(files).length) {
@@ -22126,7 +22126,7 @@ var init_diff3 = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/@fern-api+replay@0.15.0/node_modules/@fern-api/replay/dist/index.js
+// ../../node_modules/.pnpm/@fern-api+replay@0.15.1/node_modules/@fern-api/replay/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
   CREDENTIAL_PATTERNS: () => CREDENTIAL_PATTERNS,
@@ -22468,73 +22468,55 @@ function parseRevertedMessage(subject) {
   const match2 = subject.match(/^Revert "(.+)"$/);
   return match2?.[1];
 }
-function trimCR(line) {
-  return line.endsWith("\r") ? line.slice(0, -1) : line;
+function isBinaryFile(filePath) {
+  const ext2 = (0, import_path9.extname)(filePath).toLowerCase();
+  return BINARY_EXTENSIONS.has(ext2);
 }
-function findConflictRanges(lines) {
-  const ranges = [];
-  let i2 = 0;
-  while (i2 < lines.length) {
-    if (trimCR(lines[i2]) === CONFLICT_OPENER) {
-      let separatorIdx = -1;
-      let j2 = i2 + 1;
-      let found = false;
-      while (j2 < lines.length) {
-        const trimmed2 = trimCR(lines[j2]);
-        if (trimmed2 === CONFLICT_OPENER) {
-          break;
-        }
-        if (separatorIdx === -1 && trimmed2 === CONFLICT_SEPARATOR) {
-          separatorIdx = j2;
-        } else if (separatorIdx !== -1 && trimmed2 === CONFLICT_CLOSER) {
-          ranges.push({ start: i2, separator: separatorIdx, end: j2 });
-          i2 = j2;
-          found = true;
-          break;
-        }
-        j2++;
+function parsePatchFileHeaders(patchContent) {
+  const results = [];
+  let currentPath = null;
+  let currentIsCreate = false;
+  let currentIsDelete = false;
+  const flush2 = () => {
+    if (currentPath !== null) {
+      results.push({ path: currentPath, isCreate: currentIsCreate, isDelete: currentIsDelete });
+    }
+  };
+  for (const line of patchContent.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      flush2();
+      currentPath = null;
+      currentIsCreate = false;
+      currentIsDelete = false;
+      const match2 = line.match(/^diff --git a\/(.+?) b\/(.+?)$/);
+      if (match2) {
+        currentPath = match2[2] ?? null;
       }
-      if (!found) {
-        i2++;
-        continue;
+    } else if (currentPath !== null) {
+      if (line.startsWith("new file mode ")) {
+        currentIsCreate = true;
+      } else if (line.startsWith("deleted file mode ")) {
+        currentIsDelete = true;
       }
     }
-    i2++;
   }
-  return ranges;
+  flush2();
+  return results;
 }
-function stripConflictMarkers(content) {
-  const lines = content.split(/\r?\n/);
-  const ranges = findConflictRanges(lines);
-  if (ranges.length === 0) {
-    return content;
+async function capturePatchSnapshot(git, files, treeish) {
+  const snapshot = {};
+  for (const file of files) {
+    if (isBinaryFile(file)) continue;
+    const content = await git.showFile(treeish, file).catch(() => null);
+    if (content != null) snapshot[file] = content;
   }
-  const result = [];
-  let rangeIdx = 0;
-  for (let i2 = 0; i2 < lines.length; i2++) {
-    if (rangeIdx < ranges.length) {
-      const range2 = ranges[rangeIdx];
-      if (i2 === range2.start) {
-        continue;
-      }
-      if (i2 > range2.start && i2 < range2.separator) {
-        result.push(lines[i2]);
-        continue;
-      }
-      if (i2 === range2.separator) {
-        continue;
-      }
-      if (i2 > range2.separator && i2 < range2.end) {
-        continue;
-      }
-      if (i2 === range2.end) {
-        rangeIdx++;
-        continue;
-      }
-    }
-    result.push(lines[i2]);
-  }
-  return result.join("\n");
+  return snapshot;
+}
+function filterInfrastructureAndSensitiveFiles(rawFilesOutput) {
+  const allFiles = rawFilesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
+  const sensitiveFiles = allFiles.filter((f) => isSensitiveFile(f));
+  const files = allFiles.filter((f) => !isSensitiveFile(f));
+  return { files, sensitiveFiles };
 }
 function threeWayMerge(base, ours, theirs) {
   const baseLines = base.split("\n");
@@ -22672,9 +22654,331 @@ function applyBothPatches(baseLines, oursPatches, theirsPatches) {
   }
   return result;
 }
-function isBinaryFile(filePath) {
-  const ext2 = (0, import_path9.extname)(filePath).toLowerCase();
-  return BINARY_EXTENSIONS.has(ext2);
+async function resolveInputs(args) {
+  const {
+    patch,
+    filePath,
+    git,
+    lockManager,
+    outputDir,
+    isTreeReachable,
+    resolveBaseGeneration,
+    resolveFilePath,
+    extractRenameSource,
+    extractFileDiff: extractFileDiff2
+  } = args;
+  const baseGen = await resolveBaseGeneration(patch.base_generation);
+  if (!baseGen) {
+    return {
+      resolvedPath: filePath,
+      metadata: {
+        patchId: patch.id,
+        patchMessage: patch.original_message,
+        baseGeneration: patch.base_generation,
+        currentGeneration: lockManager.read().current_generation
+      },
+      base: null,
+      ours: null,
+      oursPath: (0, import_path11.join)(outputDir, filePath),
+      renameSourcePath: void 0,
+      ghostTheirs: null,
+      earlyExit: { status: "skipped", reason: "base-generation-not-found" }
+    };
+  }
+  const lock = lockManager.read();
+  const currentGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
+  const currentTreeHash = currentGen?.tree_hash ?? baseGen.tree_hash;
+  const resolvedPath = await resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
+  const metadata = {
+    patchId: patch.id,
+    patchMessage: patch.original_message,
+    baseGeneration: patch.base_generation,
+    currentGeneration: lock.current_generation
+  };
+  let base = await git.showFile(baseGen.tree_hash, filePath);
+  let renameSourcePath;
+  if (!base) {
+    const renameSource = extractRenameSource(patch.patch_content, filePath);
+    if (renameSource) {
+      base = await git.showFile(baseGen.tree_hash, renameSource);
+      renameSourcePath = renameSource;
+    }
+  }
+  const oursPath = (0, import_path11.join)(outputDir, resolvedPath);
+  const ours = await (0, import_promises5.readFile)(oursPath, "utf-8").catch(() => null);
+  let ghostTheirs = null;
+  if (!base && ours && !renameSourcePath) {
+    const treeReachable = await isTreeReachable(baseGen.tree_hash);
+    if (!treeReachable) {
+      const fileDiff = extractFileDiff2(patch.patch_content, filePath);
+      if (fileDiff) {
+        const { reconstructFromGhostPatch: reconstructFromGhostPatch2 } = await Promise.resolve().then(() => (init_HybridReconstruction(), HybridReconstruction_exports));
+        const result = reconstructFromGhostPatch2(fileDiff, ours);
+        if (result) {
+          base = result.base;
+          ghostTheirs = result.theirs;
+        }
+      }
+    }
+  }
+  return {
+    resolvedPath,
+    metadata,
+    base,
+    ours,
+    oursPath,
+    renameSourcePath,
+    ghostTheirs
+  };
+}
+function trimCR(line) {
+  return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+function findConflictRanges(lines) {
+  const ranges = [];
+  let i2 = 0;
+  while (i2 < lines.length) {
+    if (trimCR(lines[i2]) === CONFLICT_OPENER) {
+      let separatorIdx = -1;
+      let j2 = i2 + 1;
+      let found = false;
+      while (j2 < lines.length) {
+        const trimmed2 = trimCR(lines[j2]);
+        if (trimmed2 === CONFLICT_OPENER) {
+          break;
+        }
+        if (separatorIdx === -1 && trimmed2 === CONFLICT_SEPARATOR) {
+          separatorIdx = j2;
+        } else if (separatorIdx !== -1 && trimmed2 === CONFLICT_CLOSER) {
+          ranges.push({ start: i2, separator: separatorIdx, end: j2 });
+          i2 = j2;
+          found = true;
+          break;
+        }
+        j2++;
+      }
+      if (!found) {
+        i2++;
+        continue;
+      }
+    }
+    i2++;
+  }
+  return ranges;
+}
+function stripConflictMarkers(content) {
+  const lines = content.split(/\r?\n/);
+  const ranges = findConflictRanges(lines);
+  if (ranges.length === 0) {
+    return content;
+  }
+  const result = [];
+  let rangeIdx = 0;
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    if (rangeIdx < ranges.length) {
+      const range2 = ranges[rangeIdx];
+      if (i2 === range2.start) {
+        continue;
+      }
+      if (i2 > range2.start && i2 < range2.separator) {
+        result.push(lines[i2]);
+        continue;
+      }
+      if (i2 === range2.separator) {
+        continue;
+      }
+      if (i2 > range2.separator && i2 < range2.end) {
+        continue;
+      }
+      if (i2 === range2.end) {
+        rangeIdx++;
+        continue;
+      }
+    }
+    result.push(lines[i2]);
+  }
+  return result.join("\n");
+}
+function hasConflictMarkerStrings(content) {
+  if (content == null) return false;
+  return content.includes(CONFLICT_OPENER) || content.includes(CONFLICT_CLOSER);
+}
+async function buildMergePlan(args) {
+  const {
+    inputs,
+    patch,
+    filePath,
+    accumulator,
+    tempGit,
+    tempDir,
+    applyPatchToContent: applyPatchToContent2,
+    isPatchAlreadyApplied
+  } = args;
+  const { base, ours, resolvedPath, renameSourcePath, ghostTheirs } = inputs;
+  let theirs = ghostTheirs;
+  const ghostReconstructed = ghostTheirs != null;
+  const snapshotForFile = patch.theirs_snapshot?.[resolvedPath] ?? patch.theirs_snapshot?.[filePath];
+  const fileIsShared = accumulator.isShared(resolvedPath) || accumulator.isShared(filePath);
+  const useSnapshotAsPrimary = !fileIsShared && snapshotForFile != null;
+  let primarySource = ghostReconstructed ? "ghost" : "reconstructed";
+  if (!ghostReconstructed) {
+    if (useSnapshotAsPrimary) {
+      theirs = snapshotForFile;
+      primarySource = "snapshot";
+    } else {
+      theirs = await applyPatchToContent2(
+        base,
+        patch.patch_content,
+        filePath,
+        tempGit,
+        tempDir,
+        renameSourcePath
+      );
+      const reconstructionHasMarkers = hasConflictMarkerStrings(theirs);
+      const baseHadMarkers = hasConflictMarkerStrings(base);
+      if (reconstructionHasMarkers && !baseHadMarkers && snapshotForFile != null) {
+        theirs = snapshotForFile;
+      }
+    }
+  }
+  const accumulatorEntry = accumulator.lookup(resolvedPath);
+  if (theirs) {
+    const theirsHasMarkers = hasConflictMarkerStrings(theirs);
+    const baseHasMarkers = hasConflictMarkerStrings(base);
+    if (theirsHasMarkers && !baseHasMarkers) {
+      if (accumulatorEntry) {
+        theirs = null;
+      } else {
+        return { kind: "skipped", reason: "stale-conflict-markers" };
+      }
+    }
+  }
+  let useAccumulatorAsMergeBase = false;
+  if (accumulatorEntry && (theirs == null || base == null)) {
+    theirs = await applyPatchToContent2(
+      accumulatorEntry.content,
+      patch.patch_content,
+      filePath,
+      tempGit,
+      tempDir
+    );
+    if (theirs != null) {
+      useAccumulatorAsMergeBase = true;
+    } else if (await isPatchAlreadyApplied(
+      patch.patch_content,
+      filePath,
+      accumulatorEntry.content,
+      tempGit,
+      tempDir
+    )) {
+      theirs = accumulatorEntry.content;
+      useAccumulatorAsMergeBase = true;
+    }
+  }
+  if (theirs) {
+    const theirsHasMarkers = hasConflictMarkerStrings(theirs);
+    const accBaseHasMarkers = accumulatorEntry != null && hasConflictMarkerStrings(accumulatorEntry.content);
+    if (theirsHasMarkers && !accBaseHasMarkers && !hasConflictMarkerStrings(base)) {
+      return { kind: "skipped", reason: "stale-conflict-markers" };
+    }
+  }
+  let effective_theirs = theirs;
+  let conflictReasonHint;
+  if (theirs != null && base != null && !useAccumulatorAsMergeBase) {
+    if (accumulatorEntry && accumulatorEntry.baseGeneration === patch.base_generation) {
+      try {
+        const preMerged = threeWayMerge(base, accumulatorEntry.content, theirs);
+        if (!preMerged.hasConflicts) {
+          effective_theirs = preMerged.content;
+        } else {
+          effective_theirs = theirs;
+        }
+      } catch {
+        effective_theirs = theirs;
+      }
+    } else if (accumulatorEntry) {
+      conflictReasonHint = "base-generation-mismatch";
+    }
+  }
+  if (base == null && ours == null && effective_theirs != null) {
+    return { kind: "new-file-only-user", theirs: effective_theirs };
+  }
+  if (base == null && ours != null && effective_theirs != null && !useAccumulatorAsMergeBase) {
+    return { kind: "new-file-both", theirs: effective_theirs };
+  }
+  if (effective_theirs == null) {
+    return { kind: "skipped", reason: "missing-content" };
+  }
+  if (base == null && !useAccumulatorAsMergeBase || ours == null) {
+    return { kind: "skipped", reason: "missing-content" };
+  }
+  if (useAccumulatorAsMergeBase) {
+    const mergeBase = accumulatorEntry?.content ?? base;
+    if (mergeBase == null) {
+      return { kind: "skipped", reason: "missing-content" };
+    }
+    return {
+      kind: "accumulator-base",
+      theirs: effective_theirs,
+      mergeBase,
+      conflictReasonHint
+    };
+  }
+  return {
+    kind: primarySource,
+    base,
+    theirs: effective_theirs,
+    mergeBase: base,
+    conflictReasonHint
+  };
+}
+async function runMergeAndRecord(args) {
+  const { plan, inputs, patch, accumulator } = args;
+  const { resolvedPath, metadata, oursPath, ours } = inputs;
+  if (plan.kind === "skipped") {
+    return { file: resolvedPath, status: "skipped", reason: plan.reason };
+  }
+  if (plan.kind === "new-file-only-user") {
+    accumulator.recordMerge(resolvedPath, plan.theirs, patch.base_generation);
+    await (0, import_promises6.mkdir)((0, import_path12.dirname)(oursPath), { recursive: true });
+    await (0, import_promises6.writeFile)(oursPath, plan.theirs);
+    return { file: resolvedPath, status: "merged", reason: "new-file" };
+  }
+  if (plan.kind === "new-file-both") {
+    const merged2 = threeWayMerge("", ours, plan.theirs);
+    await (0, import_promises6.mkdir)((0, import_path12.dirname)(oursPath), { recursive: true });
+    await (0, import_promises6.writeFile)(oursPath, merged2.content);
+    if (merged2.hasConflicts) {
+      return {
+        file: resolvedPath,
+        status: "conflict",
+        conflicts: merged2.conflicts,
+        conflictReason: "new-file-both",
+        conflictMetadata: metadata
+      };
+    }
+    accumulator.recordMerge(resolvedPath, merged2.content, patch.base_generation);
+    return { file: resolvedPath, status: "merged" };
+  }
+  const merged = threeWayMerge(plan.mergeBase, ours, plan.theirs);
+  await (0, import_promises6.mkdir)((0, import_path12.dirname)(oursPath), { recursive: true });
+  await (0, import_promises6.writeFile)(oursPath, merged.content);
+  if (merged.hasConflicts) {
+    accumulator.recordConflict(resolvedPath, plan.theirs, patch.base_generation);
+    return {
+      file: resolvedPath,
+      status: "conflict",
+      conflicts: merged.conflicts,
+      conflictReason: plan.conflictReasonHint ?? "same-line-edit",
+      conflictMetadata: metadata
+    };
+  }
+  accumulator.recordMerge(resolvedPath, plan.theirs, patch.base_generation);
+  return {
+    file: resolvedPath,
+    status: "merged",
+    ...merged.droppedContextLines && merged.droppedContextLines.length > 0 ? { droppedContextLines: merged.droppedContextLines } : {}
+  };
 }
 function computeDroppedContextLinesForFile(base, theirs, finalContent) {
   const baseLines = base.split("\n");
@@ -22704,37 +23008,6 @@ function isDiffLineForFile(diffLine, filePath) {
   const match2 = diffLine.match(/^diff --git a\/.+ b\/(.+)$/);
   return match2 !== null && match2[1] === filePath;
 }
-function parsePatchFileHeaders(patchContent) {
-  const results = [];
-  let currentPath = null;
-  let currentIsCreate = false;
-  let currentIsDelete = false;
-  const flush2 = () => {
-    if (currentPath !== null) {
-      results.push({ path: currentPath, isCreate: currentIsCreate, isDelete: currentIsDelete });
-    }
-  };
-  for (const line of patchContent.split("\n")) {
-    if (line.startsWith("diff --git ")) {
-      flush2();
-      currentPath = null;
-      currentIsCreate = false;
-      currentIsDelete = false;
-      const match2 = line.match(/^diff --git a\/(.+?) b\/(.+?)$/);
-      if (match2) {
-        currentPath = match2[2] ?? null;
-      }
-    } else if (currentPath !== null) {
-      if (line.startsWith("new file mode ")) {
-        currentIsCreate = true;
-      } else if (line.startsWith("deleted file mode ")) {
-        currentIsDelete = true;
-      }
-    }
-  }
-  flush2();
-  return results;
-}
 function normalizeHunkBody(hunk) {
   let contextC = 0;
   let removeC = 0;
@@ -22939,17 +23212,17 @@ function overlayRegions(currentGenLines, locInCurrentGen, workingTreeLines, locI
 }
 async function unifiedDiff(beforeContent, afterContent, filePath) {
   if (beforeContent === afterContent) return "";
-  const tmp4 = await (0, import_promises6.mkdtemp)((0, import_path11.join)((0, import_os3.tmpdir)(), "fern-replay-pp-"));
+  const tmp4 = await (0, import_promises8.mkdtemp)((0, import_path14.join)((0, import_os3.tmpdir)(), "fern-replay-pp-"));
   try {
-    const beforePath = (0, import_path11.join)(tmp4, "before");
-    const afterPath = (0, import_path11.join)(tmp4, "after");
-    await (0, import_promises6.writeFile)(beforePath, beforeContent, "utf-8");
-    await (0, import_promises6.writeFile)(afterPath, afterContent, "utf-8");
+    const beforePath = (0, import_path14.join)(tmp4, "before");
+    const afterPath = (0, import_path14.join)(tmp4, "after");
+    await (0, import_promises8.writeFile)(beforePath, beforeContent, "utf-8");
+    await (0, import_promises8.writeFile)(afterPath, afterContent, "utf-8");
     const raw = await runGitDiffNoIndex(beforePath, afterPath);
     if (!raw.trim()) return "";
     return rewriteDiffHeaders(raw, filePath);
   } finally {
-    await (0, import_promises6.rm)(tmp4, { recursive: true, force: true });
+    await (0, import_promises8.rm)(tmp4, { recursive: true, force: true });
   }
 }
 function runGitDiffNoIndex(beforePath, afterPath) {
@@ -23020,6 +23293,37 @@ function synthesizeDeleteFileDiff(file, content) {
   const trailer = hasTrailingNewline ? "" : "\n\";
   return header + "\n" + body + trailer + "\n";
 }
+function fileIsCreationInPatchContent(patchContent, file) {
+  const lines = patchContent.split("\n");
+  let inFileSection = false;
+  for (const line of lines) {
+    if (line.startsWith("diff --git ")) {
+      inFileSection = line.includes(` b/${file}`) || line.endsWith(` b/${file}`);
+      continue;
+    }
+    if (inFileSection && line.startsWith("--- ")) {
+      return line === "--- /dev/null";
+    }
+  }
+  return false;
+}
+function firstGenerationReport() {
+  return {
+    flow: "first-generation",
+    patchesDetected: 0,
+    patchesApplied: 0,
+    patchesWithConflicts: 0,
+    patchesSkipped: 0,
+    conflicts: []
+  };
+}
+function assertActive(prep) {
+  if (prep._prepared.kind !== "active") {
+    throw new Error(
+      `Flow.apply() called with terminal preparation (kind=${prep._prepared.kind}); terminal cases must be handled by applyPreparedReplay's dispatcher`
+    );
+  }
+}
 function computeCommitBuckets(results, absorbedPatchIds, patchesPassedToCommit) {
   const resultByPatchId = /* @__PURE__ */ new Map();
   for (const r2 of results) resultByPatchId.set(r2.patch.id, r2);
@@ -23211,7 +23515,7 @@ function parseGitLog(log) {
   });
 }
 function ensureFernignoreEntries(outputDir) {
-  const fernignorePath = (0, import_path13.join)(outputDir, ".fernignore");
+  const fernignorePath = (0, import_path16.join)(outputDir, ".fernignore");
   let content = "";
   if ((0, import_fs9.existsSync)(fernignorePath)) {
     content = (0, import_fs9.readFileSync)(fernignorePath, "utf-8");
@@ -23234,7 +23538,7 @@ function ensureFernignoreEntries(outputDir) {
   return true;
 }
 function ensureGitattributesEntries(outputDir) {
-  const gitattributesPath = (0, import_path13.join)(outputDir, ".gitattributes");
+  const gitattributesPath = (0, import_path16.join)(outputDir, ".gitattributes");
   let content = "";
   if ((0, import_fs9.existsSync)(gitattributesPath)) {
     content = (0, import_fs9.readFileSync)(gitattributesPath, "utf-8");
@@ -23462,7 +23766,7 @@ async function resolve7(outputDir, options) {
       const result = await computePerPatchDiffWithFallback(
         patch,
         (f) => git.showFile(currentGen, f),
-        (f) => (0, import_promises7.readFile)((0, import_path14.join)(outputDir, f), "utf-8").catch(() => null),
+        (f) => (0, import_promises9.readFile)((0, import_path17.join)(outputDir, f), "utf-8").catch(() => null),
         (files) => git.exec(["diff", currentGen, "--", ...files]).catch(() => null)
       );
       if (result === null) {
@@ -23518,7 +23822,7 @@ async function resolve7(outputDir, options) {
       const theirsSnapshot = {};
       for (const file of filesForSnapshot) {
         if (isBinaryFile(file)) continue;
-        const content = await (0, import_promises7.readFile)((0, import_path14.join)(outputDir, file), "utf-8").catch(() => null);
+        const content = await (0, import_promises9.readFile)((0, import_path17.join)(outputDir, file), "utf-8").catch(() => null);
         if (content != null) {
           theirsSnapshot[file] = content;
         }
@@ -23628,9 +23932,9 @@ function status(outputDir) {
     excludePatterns
   };
 }
-var import_promises3, import_os, import_path7, import_fs6, import_path8, import_yaml, import_crypto, import_promises4, import_os2, import_path9, import_fs7, import_promises5, import_path10, import_promises6, import_os3, import_path11, import_child_process3, import_crypto2, import_fs8, import_path12, import_yaml2, import_crypto3, import_fs9, import_path13, import_fs10, import_promises7, import_path14, __defProp3, __getOwnPropNames3, __esm3, __export3, GitClient_exports, GitClient, init_GitClient, HybridReconstruction_exports, init_HybridReconstruction, PatchApplyTheirs_exports, init_PatchApplyTheirs, CREDENTIAL_PATTERNS, SENSITIVE_FILE_PATTERNS, FERN_BOT_NAME, FERN_BOT_EMAIL, FERN_BOT_LOGIN, FERN_SUPPORT_NAMES, LOCKFILE_HEADER, LockfileNotFoundError, LockfileManager, CONFLICT_OPENER, CONFLICT_SEPARATOR, CONFLICT_CLOSER, BINARY_EXTENSIONS, ReplayApplicator, INFRASTRUCTURE_FILES, ReplayDetector, ReplayCommitter, ReplayService, FernignoreMigrator, REPLAY_FERNIGNORE_ENTRIES, GITATTRIBUTES_ENTRIES, EMPTY_RESULT;
+var import_promises3, import_os, import_path7, import_fs6, import_path8, import_yaml, import_crypto, import_path9, import_promises4, import_os2, import_path10, import_promises5, import_path11, import_promises6, import_path12, import_fs7, import_promises7, import_path13, import_promises8, import_os3, import_path14, import_child_process3, import_crypto2, import_fs8, import_path15, import_yaml2, import_crypto3, import_fs9, import_path16, import_fs10, import_promises9, import_path17, __defProp3, __getOwnPropNames3, __esm3, __export3, GitClient_exports, GitClient, init_GitClient, HybridReconstruction_exports, init_HybridReconstruction, PatchApplyTheirs_exports, init_PatchApplyTheirs, CREDENTIAL_PATTERNS, SENSITIVE_FILE_PATTERNS, FERN_BOT_NAME, FERN_BOT_EMAIL, FERN_BOT_LOGIN, FERN_SUPPORT_NAMES, LOCKFILE_HEADER, LockfileNotFoundError, LockfileManager, BINARY_EXTENSIONS, INFRASTRUCTURE_FILES, ReplayDetector, MergeAccumulator, CONFLICT_OPENER, CONFLICT_SEPARATOR, CONFLICT_CLOSER, ReplayApplicator, ReplayCommitter, FileOwnership, FirstGenerationFlow, SkipApplicationFlow, NoPatchesFlow, NormalRegenerationFlow, ReplayService, FernignoreMigrator, REPLAY_FERNIGNORE_ENTRIES, GITATTRIBUTES_ENTRIES, EMPTY_RESULT;
 var init_dist3 = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.15.0/node_modules/@fern-api/replay/dist/index.js"() {
+  "../../node_modules/.pnpm/@fern-api+replay@0.15.1/node_modules/@fern-api/replay/dist/index.js"() {
     "use strict";
     init_esm4();
     import_promises3 = require("fs/promises");
@@ -23640,31 +23944,37 @@ var init_dist3 = __esm({
     import_path8 = require("path");
     import_yaml = __toESM(require_dist3(), 1);
     import_crypto = require("crypto");
-    import_promises4 = require("fs/promises");
-    import_os2 = require("os");
     import_path9 = require("path");
-    init_esm3();
     init_diff3();
-    import_fs7 = require("fs");
-    import_promises5 = require("fs/promises");
+    import_promises4 = require("fs/promises");
+    import_os2 = require("os");
     import_path10 = require("path");
     init_esm3();
+    import_promises5 = require("fs/promises");
+    import_path11 = require("path");
     import_promises6 = require("fs/promises");
+    import_path12 = require("path");
+    import_fs7 = require("fs");
+    import_promises7 = require("fs/promises");
+    import_path13 = require("path");
+    init_esm3();
+    import_promises8 = require("fs/promises");
     import_os3 = require("os");
-    import_path11 = require("path");
+    import_path14 = require("path");
     import_child_process3 = require("child_process");
+    init_esm3();
     import_crypto2 = require("crypto");
     import_fs8 = require("fs");
-    import_path12 = require("path");
+    import_path15 = require("path");
     init_esm3();
     import_yaml2 = __toESM(require_dist3(), 1);
     import_crypto3 = require("crypto");
     import_fs9 = require("fs");
-    import_path13 = require("path");
+    import_path16 = require("path");
     init_esm3();
     import_fs10 = require("fs");
-    import_promises7 = require("fs/promises");
-    import_path14 = require("path");
+    import_promises9 = require("fs/promises");
+    import_path17 = require("path");
     __defProp3 = Object.defineProperty;
     __getOwnPropNames3 = Object.getOwnPropertyNames;
     __esm3 = (fn, res) => function __init() {
@@ -24044,9 +24354,6 @@ var init_dist3 = __esm({
         }
       }
     };
-    CONFLICT_OPENER = "<<<<<<< Generated";
-    CONFLICT_SEPARATOR = "=======";
-    CONFLICT_CLOSER = ">>>>>>> Your customization";
     BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
       ".png",
       ".jpg",
@@ -24096,696 +24403,6 @@ var init_dist3 = __esm({
       ".pyo",
       ".DS_Store"
     ]);
-    ReplayApplicator = class {
-      git;
-      lockManager;
-      outputDir;
-      renameCache = /* @__PURE__ */ new Map();
-      treeExistsCache = /* @__PURE__ */ new Map();
-      fileTheirsAccumulator = /* @__PURE__ */ new Map();
-      /**
-       * Apply mode for the current `applyPatches` invocation. Set at the start
-       * of `applyPatches`, read by `mergeFile` to decide:
-       *   - whether to skip the intra-loop marker strip (kept in `applyPatches`)
-       *   - whether to populate the accumulator after a conflicted merge
-       *     (resolve mode populates so subsequent patches on the same file
-       *     can use patch A's THEIRS as a structurally-correct merge base
-       *     when their diff was authored against post-A structure)
-       *   - whether to retry THEIRS reconstruction against the accumulator
-       *     when the BASE-relative reconstruction produced markers from a
-       *     cross-patch context mismatch
-       */
-      currentApplyMode = "replay";
-      /**
-       * 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;
-        this.outputDir = outputDir;
-      }
-      /**
-       * Resolve the GenerationRecord for a patch's base_generation.
-       * Falls back to constructing an ad-hoc record from the commit's tree
-       * when base_generation isn't a tracked generation (commit-scan patches).
-       */
-      async resolveBaseGeneration(baseGeneration) {
-        const gen = this.lockManager.getGeneration(baseGeneration);
-        if (gen) return gen;
-        try {
-          const treeHash = await this.git.getTreeHash(baseGeneration);
-          return {
-            commit_sha: baseGeneration,
-            tree_hash: treeHash,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            cli_version: "unknown",
-            generator_versions: {}
-          };
-        } catch {
-          return void 0;
-        }
-      }
-      /** Reset inter-patch accumulator for a new cycle. */
-      resetAccumulator() {
-        this.fileTheirsAccumulator.clear();
-      }
-      /**
-       * @internal Test-only.
-       * Returns a defensive copy of the inter-patch accumulator. Used by the
-       * adversarial test suite (FER-9791) to assert invariant I2: after every
-       * applied patch, the accumulator has an entry for each file the patch
-       * touched, and the entry's content matches on-disk.
-       */
-      getAccumulatorSnapshot() {
-        const snapshot = /* @__PURE__ */ new Map();
-        for (const [path5, entry] of this.fileTheirsAccumulator) {
-          snapshot.set(path5, { content: entry.content, baseGeneration: entry.baseGeneration });
-        }
-        return snapshot;
-      }
-      /**
-       * Apply all patches, returning results for each.
-       * Skips patches that match exclude patterns in replay.yml
-       *
-       * `applyMode` controls the post-conflict marker strategy:
-       *   - `"replay"` (default): strip conflict markers from disk between
-       *     iterations whenever a later patch touches the same file. Lets the
-       *     follow-up patch's `git apply --3way` see clean OURS content,
-       *     which is what the silent-loss fix (PR #73) relies on. The replay
-       *     pipeline calls `revertConflictingFiles` after the loop to clean
-       *     any markers that survive.
-       *   - `"resolve"`: keep markers on disk. The resolve command needs the
-       *     customer to see them. Slow-path 3-way merge naturally preserves
-       *     A's markers and B's clean writes when their regions don't overlap;
-       *     when they do overlap, the customer gets nested markers and
-       *     resolves manually. Either way they aren't silently dropped.
-       */
-      async applyPatches(patches, opts) {
-        const applyMode = opts?.applyMode ?? "replay";
-        this.currentApplyMode = applyMode;
-        this.resetAccumulator();
-        const fileFreq = /* @__PURE__ */ new Map();
-        for (const p2 of patches) {
-          for (const f of p2.files) {
-            fileFreq.set(f, (fileFreq.get(f) ?? 0) + 1);
-          }
-        }
-        this.sharedFiles = new Set(
-          Array.from(fileFreq.entries()).filter(([, n]) => n > 1).map(([f]) => f)
-        );
-        const results = [];
-        for (let i2 = 0; i2 < patches.length; i2++) {
-          const patch = patches[i2];
-          if (this.isExcluded(patch)) {
-            results.push({
-              patch,
-              status: "skipped",
-              method: "git-am"
-            });
-            continue;
-          }
-          const result = await this.applyPatchWithFallback(patch);
-          results.push(result);
-          if (applyMode !== "resolve" && result.status === "conflict" && result.fileResults) {
-            const laterFiles = /* @__PURE__ */ new Set();
-            for (let j2 = i2 + 1; j2 < patches.length; j2++) {
-              for (const f of patches[j2].files) {
-                laterFiles.add(f);
-              }
-            }
-            const resolvedToOriginal = /* @__PURE__ */ new Map();
-            if (result.resolvedFiles) {
-              for (const [orig, resolved] of Object.entries(result.resolvedFiles)) {
-                resolvedToOriginal.set(resolved, orig);
-              }
-            }
-            for (const fileResult of result.fileResults) {
-              if (fileResult.status !== "conflict") continue;
-              const originalPath = resolvedToOriginal.get(fileResult.file) ?? fileResult.file;
-              if (laterFiles.has(fileResult.file) || laterFiles.has(originalPath)) {
-                const filePath = (0, import_path9.join)(this.outputDir, fileResult.file);
-                try {
-                  const content = await (0, import_promises4.readFile)(filePath, "utf-8");
-                  const stripped = stripConflictMarkers(content);
-                  await (0, import_promises4.writeFile)(filePath, stripped);
-                } catch {
-                }
-              }
-            }
-          }
-        }
-        return results;
-      }
-      /**
-       * Populate accumulator after git apply succeeds, AND collect per-file
-       * results including any "dropped context lines" — lines that were
-       * present in BASE and THEIRS (unchanged context) but absent from the
-       * final on-disk state because OURS deleted them. This is the fast-path
-       * counterpart to ThreeWayMerge.computeDroppedContextLines used by the
-       * 3-way slow path; both must surface the same warning.
-       */
-      async populateAccumulatorForPatch(patch, baseGen, currentTreeHash) {
-        const fileResults = [];
-        if (!baseGen) return fileResults;
-        const tempDir = await (0, import_promises4.mkdtemp)((0, import_path9.join)((0, import_os2.tmpdir)(), "replay-acc-"));
-        const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
-        const tempGit = new GitClient2(tempDir);
-        await tempGit.exec(["init"]);
-        await tempGit.exec(["config", "user.email", "replay@fern.com"]);
-        await tempGit.exec(["config", "user.name", "Fern Replay"]);
-        try {
-          for (const filePath of patch.files) {
-            if (isBinaryFile(filePath)) continue;
-            const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
-            const base = await this.git.showFile(baseGen.tree_hash, filePath);
-            const snapshotForFile = patch.theirs_snapshot?.[resolvedPath] ?? patch.theirs_snapshot?.[filePath];
-            const fileIsShared = this.sharedFiles.has(resolvedPath) || this.sharedFiles.has(filePath);
-            const theirs = !fileIsShared && snapshotForFile != null ? snapshotForFile : await this.applyPatchToContent(base, patch.patch_content, filePath, tempGit, tempDir);
-            const finalOnDisk = await (0, import_promises4.readFile)((0, import_path9.join)(this.outputDir, resolvedPath), "utf-8").catch(() => null);
-            const effectiveTheirs = theirs ?? finalOnDisk;
-            if (effectiveTheirs != null) {
-              this.fileTheirsAccumulator.set(resolvedPath, {
-                content: effectiveTheirs,
-                baseGeneration: patch.base_generation
-              });
-            }
-            if (base != null && effectiveTheirs != null && finalOnDisk != null) {
-              const dropped = computeDroppedContextLinesForFile(base, effectiveTheirs, finalOnDisk);
-              if (dropped.length > 0) {
-                fileResults.push({
-                  file: resolvedPath,
-                  status: "merged",
-                  droppedContextLines: dropped
-                });
-              }
-            }
-          }
-        } finally {
-          await (0, import_promises4.rm)(tempDir, { recursive: true }).catch(() => {
-          });
-        }
-        return fileResults;
-      }
-      async applyPatchWithFallback(patch) {
-        const baseGen = await this.resolveBaseGeneration(patch.base_generation);
-        const lock = this.lockManager.read();
-        const currentGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
-        const currentTreeHash = currentGen?.tree_hash ?? baseGen?.tree_hash ?? "";
-        const needsAccumulation = await Promise.all(
-          patch.files.map(async (f) => {
-            if (!baseGen) return false;
-            const resolved = await this.resolveFilePath(f, baseGen.tree_hash, currentTreeHash);
-            return this.fileTheirsAccumulator.has(resolved);
-          })
-        ).then((results) => results.some(Boolean));
-        const resolvedFiles = {};
-        for (const filePath of patch.files) {
-          const resolvedPath = baseGen ? await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash) : filePath;
-          if (resolvedPath !== filePath) {
-            resolvedFiles[filePath] = resolvedPath;
-          }
-        }
-        const patchIsRenameAware = /^rename from /m.test(patch.patch_content);
-        const hasGeneratorRename = Object.keys(resolvedFiles).length > 0 && !patchIsRenameAware;
-        if (!needsAccumulation && !hasGeneratorRename) {
-          const snapshots = /* @__PURE__ */ new Map();
-          for (const filePath of patch.files) {
-            const fullPath = (0, import_path9.join)(this.outputDir, filePath);
-            snapshots.set(filePath, await (0, import_promises4.readFile)(fullPath, "utf-8").catch(() => null));
-          }
-          try {
-            await this.git.execWithInput(["apply", "--3way"], patch.patch_content);
-            const fastPathFileResults = await this.populateAccumulatorForPatch(patch, baseGen, currentTreeHash);
-            return {
-              patch,
-              status: "applied",
-              method: "git-am",
-              ...fastPathFileResults.length > 0 && { fileResults: fastPathFileResults },
-              ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
-            };
-          } catch {
-            for (const [filePath, content] of snapshots) {
-              const fullPath = (0, import_path9.join)(this.outputDir, filePath);
-              if (content != null) {
-                await (0, import_promises4.writeFile)(fullPath, content);
-              } else {
-                await (0, import_promises4.unlink)(fullPath).catch(() => {
-                });
-              }
-            }
-          }
-        }
-        return this.applyWithThreeWayMerge(patch);
-      }
-      async applyWithThreeWayMerge(patch) {
-        const fileResults = [];
-        const resolvedFiles = {};
-        const tempDir = await (0, import_promises4.mkdtemp)((0, import_path9.join)((0, import_os2.tmpdir)(), "replay-"));
-        const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
-        const tempGit = new GitClient2(tempDir);
-        await tempGit.exec(["init"]);
-        await tempGit.exec(["config", "user.email", "replay@fern.com"]);
-        await tempGit.exec(["config", "user.name", "Fern Replay"]);
-        try {
-          for (const filePath of patch.files) {
-            if (isBinaryFile(filePath)) {
-              fileResults.push({
-                file: filePath,
-                status: "skipped",
-                reason: "binary-file"
-              });
-              continue;
-            }
-            const result = await this.mergeFile(patch, filePath, tempGit, tempDir);
-            if (result.file !== filePath) {
-              resolvedFiles[filePath] = result.file;
-            }
-            fileResults.push(result);
-          }
-        } finally {
-          await (0, import_promises4.rm)(tempDir, { recursive: true }).catch(() => {
-          });
-        }
-        const conflictFiles = fileResults.filter((r2) => r2.status === "conflict");
-        const hasConflicts = conflictFiles.length > 0;
-        const conflictReason = hasConflicts ? conflictFiles.some((f) => f.conflictReason === "base-generation-mismatch") ? "base-generation-mismatch" : conflictFiles[0]?.conflictReason : void 0;
-        return {
-          patch,
-          status: hasConflicts ? "conflict" : "applied",
-          method: "3way-merge",
-          fileResults,
-          conflictReason,
-          ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
-        };
-      }
-      async mergeFile(patch, filePath, tempGit, tempDir) {
-        try {
-          const baseGen = await this.resolveBaseGeneration(patch.base_generation);
-          if (!baseGen) {
-            return { file: filePath, status: "skipped", reason: "base-generation-not-found" };
-          }
-          const lock = this.lockManager.read();
-          const currentGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
-          const currentTreeHash = currentGen?.tree_hash ?? baseGen.tree_hash;
-          const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
-          const metadata = {
-            patchId: patch.id,
-            patchMessage: patch.original_message,
-            baseGeneration: patch.base_generation,
-            currentGeneration: lock.current_generation
-          };
-          let base = await this.git.showFile(baseGen.tree_hash, filePath);
-          let renameSourcePath;
-          if (!base) {
-            const renameSource = this.extractRenameSource(patch.patch_content, filePath);
-            if (renameSource) {
-              base = await this.git.showFile(baseGen.tree_hash, renameSource);
-              renameSourcePath = renameSource;
-            }
-          }
-          const oursPath = (0, import_path9.join)(this.outputDir, resolvedPath);
-          const ours = await (0, import_promises4.readFile)(oursPath, "utf-8").catch(() => null);
-          let ghostReconstructed = false;
-          let theirs = null;
-          if (!base && ours && !renameSourcePath) {
-            const treeReachable = await this.isTreeReachable(baseGen.tree_hash);
-            if (!treeReachable) {
-              const fileDiff = this.extractFileDiff(patch.patch_content, filePath);
-              if (fileDiff) {
-                const { reconstructFromGhostPatch: reconstructFromGhostPatch2 } = await Promise.resolve().then(() => (init_HybridReconstruction(), HybridReconstruction_exports));
-                const result = reconstructFromGhostPatch2(fileDiff, ours);
-                if (result) {
-                  base = result.base;
-                  theirs = result.theirs;
-                  ghostReconstructed = true;
-                }
-              }
-            }
-          }
-          const snapshotForFile = patch.theirs_snapshot?.[resolvedPath] ?? patch.theirs_snapshot?.[filePath];
-          const fileIsShared = this.sharedFiles.has(resolvedPath) || this.sharedFiles.has(filePath);
-          const useSnapshotAsPrimary = !fileIsShared && snapshotForFile != null;
-          if (!ghostReconstructed) {
-            if (useSnapshotAsPrimary) {
-              theirs = snapshotForFile;
-            } else {
-              theirs = await this.applyPatchToContent(
-                base,
-                patch.patch_content,
-                filePath,
-                tempGit,
-                tempDir,
-                renameSourcePath
-              );
-              const reconstructionHasMarkers = theirs != null && (theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization"));
-              const baseHadMarkers = base != null && (base.includes("<<<<<<< Generated") || base.includes(">>>>>>> Your customization"));
-              if (reconstructionHasMarkers && !baseHadMarkers && snapshotForFile != null) {
-                theirs = snapshotForFile;
-              }
-            }
-          }
-          const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
-          if (theirs) {
-            const theirsHasMarkers = theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization");
-            const baseHasMarkers = base != null && (base.includes("<<<<<<< Generated") || base.includes(">>>>>>> Your customization"));
-            if (theirsHasMarkers && !baseHasMarkers) {
-              if (accumulatorEntry) {
-                theirs = null;
-              } else {
-                return {
-                  file: resolvedPath,
-                  status: "skipped",
-                  reason: "stale-conflict-markers"
-                };
-              }
-            }
-          }
-          let useAccumulatorAsMergeBase = false;
-          if (accumulatorEntry && (theirs == null || base == null)) {
-            theirs = await this.applyPatchToContent(
-              accumulatorEntry.content,
-              patch.patch_content,
-              filePath,
-              tempGit,
-              tempDir
-            );
-            if (theirs != null) {
-              useAccumulatorAsMergeBase = true;
-            } else if (await this.isPatchAlreadyApplied(
-              patch.patch_content,
-              filePath,
-              accumulatorEntry.content,
-              tempGit,
-              tempDir
-            )) {
-              theirs = accumulatorEntry.content;
-              useAccumulatorAsMergeBase = true;
-            }
-          }
-          if (theirs) {
-            const theirsHasMarkers = theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization");
-            const accBaseHasMarkers = accumulatorEntry != null && (accumulatorEntry.content.includes("<<<<<<< Generated") || accumulatorEntry.content.includes(">>>>>>> Your customization"));
-            if (theirsHasMarkers && !accBaseHasMarkers && !(base != null && (base.includes("<<<<<<< Generated") || base.includes(">>>>>>> Your customization")))) {
-              return {
-                file: resolvedPath,
-                status: "skipped",
-                reason: "stale-conflict-markers"
-              };
-            }
-          }
-          let effective_theirs = theirs;
-          let baseMismatchSkipped = false;
-          if (theirs != null && base != null && !useAccumulatorAsMergeBase) {
-            if (accumulatorEntry && accumulatorEntry.baseGeneration === patch.base_generation) {
-              try {
-                const preMerged = threeWayMerge(base, accumulatorEntry.content, theirs);
-                if (!preMerged.hasConflicts) {
-                  effective_theirs = preMerged.content;
-                } else {
-                  effective_theirs = theirs;
-                }
-              } catch {
-                effective_theirs = theirs;
-              }
-            } else if (accumulatorEntry) {
-              baseMismatchSkipped = true;
-            }
-          }
-          if (base == null && ours == null && effective_theirs != null) {
-            this.fileTheirsAccumulator.set(resolvedPath, {
-              content: effective_theirs,
-              baseGeneration: patch.base_generation
-            });
-            const outDir2 = (0, import_path9.dirname)(oursPath);
-            await (0, import_promises4.mkdir)(outDir2, { recursive: true });
-            await (0, import_promises4.writeFile)(oursPath, effective_theirs);
-            return { file: resolvedPath, status: "merged", reason: "new-file" };
-          }
-          if (base == null && ours != null && effective_theirs != null && !useAccumulatorAsMergeBase) {
-            const merged2 = threeWayMerge("", ours, effective_theirs);
-            const outDir2 = (0, import_path9.dirname)(oursPath);
-            await (0, import_promises4.mkdir)(outDir2, { recursive: true });
-            await (0, import_promises4.writeFile)(oursPath, merged2.content);
-            if (merged2.hasConflicts) {
-              return {
-                file: resolvedPath,
-                status: "conflict",
-                conflicts: merged2.conflicts,
-                conflictReason: "new-file-both",
-                conflictMetadata: metadata
-              };
-            }
-            this.fileTheirsAccumulator.set(resolvedPath, {
-              content: merged2.content,
-              baseGeneration: patch.base_generation
-            });
-            return { file: resolvedPath, status: "merged" };
-          }
-          if (effective_theirs == null) {
-            return {
-              file: resolvedPath,
-              status: "skipped",
-              reason: "missing-content"
-            };
-          }
-          if (base == null && !useAccumulatorAsMergeBase || ours == null) {
-            return {
-              file: resolvedPath,
-              status: "skipped",
-              reason: "missing-content"
-            };
-          }
-          const mergeBase = useAccumulatorAsMergeBase && accumulatorEntry ? accumulatorEntry.content : base;
-          if (mergeBase == null) {
-            return {
-              file: resolvedPath,
-              status: "skipped",
-              reason: "missing-content"
-            };
-          }
-          const merged = threeWayMerge(mergeBase, ours, effective_theirs);
-          const outDir = (0, import_path9.dirname)(oursPath);
-          await (0, import_promises4.mkdir)(outDir, { recursive: true });
-          await (0, import_promises4.writeFile)(oursPath, merged.content);
-          const populateAccumulator = effective_theirs != null && (!merged.hasConflicts || this.currentApplyMode === "resolve");
-          if (populateAccumulator) {
-            this.fileTheirsAccumulator.set(resolvedPath, {
-              content: effective_theirs,
-              baseGeneration: patch.base_generation
-            });
-          }
-          if (merged.hasConflicts) {
-            return {
-              file: resolvedPath,
-              status: "conflict",
-              conflicts: merged.conflicts,
-              conflictReason: baseMismatchSkipped ? "base-generation-mismatch" : "same-line-edit",
-              conflictMetadata: metadata
-            };
-          }
-          return {
-            file: resolvedPath,
-            status: "merged",
-            ...merged.droppedContextLines && merged.droppedContextLines.length > 0 ? { droppedContextLines: merged.droppedContextLines } : {}
-          };
-        } catch (error) {
-          return {
-            file: filePath,
-            status: "skipped",
-            reason: `error: ${error instanceof Error ? error.message : String(error)}`
-          };
-        }
-      }
-      async isTreeReachable(treeHash) {
-        let result = this.treeExistsCache.get(treeHash);
-        if (result === void 0) {
-          result = await this.git.treeExists(treeHash);
-          this.treeExistsCache.set(treeHash, result);
-        }
-        return result;
-      }
-      isExcluded(patch) {
-        const config = this.lockManager.getCustomizationsConfig();
-        if (!config.exclude) return false;
-        return patch.files.some((file) => config.exclude.some((pattern) => minimatch(file, pattern)));
-      }
-      async resolveFilePath(filePath, baseTreeHash, currentTreeHash) {
-        const config = this.lockManager.getCustomizationsConfig();
-        if (config.moves) {
-          for (const move of config.moves) {
-            if (minimatch(filePath, move.from) || filePath === move.from) {
-              if (filePath === move.from) {
-                return move.to;
-              }
-              const fromBase = move.from.replace(/\*\*.*$/, "");
-              const toBase = move.to.replace(/\*\*.*$/, "");
-              if (filePath.startsWith(fromBase)) {
-                return toBase + filePath.slice(fromBase.length);
-              }
-            }
-          }
-        }
-        const cacheKey = `${baseTreeHash}:${currentTreeHash}`;
-        let renames = this.renameCache.get(cacheKey);
-        if (!renames) {
-          renames = await this.git.detectRenames(baseTreeHash, currentTreeHash);
-          this.renameCache.set(cacheKey, renames);
-        }
-        const gitRename = renames.find((r2) => r2.from === filePath);
-        if (gitRename) {
-          return gitRename.to;
-        }
-        return filePath;
-      }
-      async applyPatchToContent(base, patchContent, filePath, tempGit, tempDir, sourceFilePath) {
-        if (!base) {
-          return this.extractNewFileFromPatch(patchContent, filePath);
-        }
-        const fileDiff = this.extractFileDiff(patchContent, filePath);
-        if (!fileDiff) return null;
-        try {
-          if (sourceFilePath) {
-            const tempSourcePath = (0, import_path9.join)(tempDir, sourceFilePath);
-            await (0, import_promises4.mkdir)((0, import_path9.dirname)(tempSourcePath), { recursive: true });
-            await (0, import_promises4.writeFile)(tempSourcePath, base);
-            await tempGit.exec(["add", sourceFilePath]);
-            await tempGit.exec([
-              "commit",
-              "-m",
-              `base for rename ${sourceFilePath} -> ${filePath}`,
-              "--allow-empty"
-            ]);
-            await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
-            const tempTargetPath = (0, import_path9.join)(tempDir, filePath);
-            return await (0, import_promises4.readFile)(tempTargetPath, "utf-8");
-          }
-          const tempFilePath = (0, import_path9.join)(tempDir, filePath);
-          await (0, import_promises4.mkdir)((0, import_path9.dirname)(tempFilePath), { recursive: true });
-          await (0, import_promises4.writeFile)(tempFilePath, base);
-          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_promises4.readFile)(tempFilePath, "utf-8");
-        } catch {
-          return null;
-        }
-      }
-      /**
-       * Detects whether a patch's additions are already present in `content`.
-       * Uses `git apply --reverse --check` — if the reverse patch applies cleanly,
-       * the forward patch is effectively a no-op (its +lines are already there and
-       * its -lines are already gone). Used to distinguish "patch already applied"
-       * from "patch base mismatch" after a forward-apply fails.
-       */
-      async isPatchAlreadyApplied(patchContent, filePath, content, tempGit, tempDir) {
-        const fileDiff = this.extractFileDiff(patchContent, filePath);
-        if (!fileDiff) return false;
-        try {
-          const tempFilePath = (0, import_path9.join)(tempDir, filePath);
-          await (0, import_promises4.mkdir)((0, import_path9.dirname)(tempFilePath), { recursive: true });
-          await (0, import_promises4.writeFile)(tempFilePath, content);
-          await tempGit.exec(["add", filePath]);
-          await tempGit.exec(["commit", "-m", `check already-applied ${filePath}`, "--allow-empty"]);
-          await tempGit.execWithInput(["apply", "--reverse", "--check", "--allow-empty"], fileDiff);
-          return true;
-        } catch {
-          return false;
-        }
-      }
-      extractFileDiff(patchContent, filePath) {
-        const lines = patchContent.split("\n");
-        const diffLines = [];
-        let inTargetFile = false;
-        for (const line of lines) {
-          if (line.startsWith("diff --git")) {
-            if (inTargetFile) {
-              break;
-            }
-            if (isDiffLineForFile(line, filePath)) {
-              inTargetFile = true;
-              diffLines.push(line);
-            }
-            continue;
-          }
-          if (inTargetFile) {
-            diffLines.push(line);
-          }
-        }
-        return diffLines.length > 0 ? diffLines.join("\n") + "\n" : null;
-      }
-      extractRenameSource(patchContent, targetFilePath) {
-        const lines = patchContent.split("\n");
-        let inTargetFile = false;
-        for (const line of lines) {
-          if (line.startsWith("diff --git")) {
-            if (inTargetFile) break;
-            inTargetFile = isDiffLineForFile(line, targetFilePath);
-            continue;
-          }
-          if (!inTargetFile) continue;
-          if (line.startsWith("@@")) break;
-          if (line.startsWith("rename from ")) {
-            return line.slice("rename from ".length);
-          }
-        }
-        return null;
-      }
-      extractNewFileFromPatch(patchContent, filePath) {
-        const lines = patchContent.split("\n");
-        const addedLines = [];
-        let inTargetFile = false;
-        let inHunk = false;
-        let isNewFile = false;
-        let noTrailingNewline = false;
-        for (const line of lines) {
-          if (line.startsWith("diff --git")) {
-            if (inTargetFile) break;
-            inTargetFile = isDiffLineForFile(line, filePath);
-            inHunk = false;
-            isNewFile = false;
-            continue;
-          }
-          if (!inTargetFile) continue;
-          if (!inHunk) {
-            if (line === "--- /dev/null" || line.startsWith("new file mode")) {
-              isNewFile = true;
-            }
-          }
-          if (line.startsWith("@@")) {
-            if (!isNewFile) return null;
-            inHunk = true;
-            continue;
-          }
-          if (!inHunk) continue;
-          if (line === "\") {
-            noTrailingNewline = true;
-            continue;
-          }
-          if (line.startsWith("+") && !line.startsWith("+++")) {
-            addedLines.push(line.slice(1));
-          }
-        }
-        if (addedLines.length === 0) return null;
-        return addedLines.join("\n") + (noTrailingNewline ? "" : "\n");
-      }
-    };
     INFRASTRUCTURE_FILES = /* @__PURE__ */ new Set([".fernignore"]);
     ReplayDetector = class {
       git;
@@ -24821,7 +24438,7 @@ var init_dist3 = __esm({
         return this.detectPatchesInRange(lastGen.commit_sha, lastGen, lock);
       }
       /**
-       * FER-10201 — Non-linear-history detection via `merge-base(prevGen, HEAD)`.
+       * 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
@@ -24853,7 +24470,7 @@ var init_dist3 = __esm({
         return this.detectPatchesInRange(mergeBase, lastGen, lock);
       }
       /**
-       * FER-10201 — Walk `${rangeStart}..HEAD`, classify each commit, emit one
+       * 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.
        *
@@ -24910,9 +24527,7 @@ var init_dist3 = __esm({
             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((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
-          const sensitiveFiles = allFiles.filter((f) => isSensitiveFile(f));
-          const files = allFiles.filter((f) => !isSensitiveFile(f));
+          const { files, sensitiveFiles } = filterInfrastructureAndSensitiveFiles(filesOutput);
           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.`
@@ -24933,12 +24548,7 @@ var init_dist3 = __esm({
           if (files.length === 0) {
             continue;
           }
-          const theirsSnapshot = {};
-          for (const file of files) {
-            if (isBinaryFile(file)) continue;
-            const content = await this.git.showFile(commit.sha, file).catch(() => null);
-            if (content != null) theirsSnapshot[file] = content;
-          }
+          const theirsSnapshot = await capturePatchSnapshot(this.git, files, commit.sha);
           newPatches.push({
             id: `patch-${commit.sha.slice(0, 8)}`,
             content_hash: contentHash,
@@ -25026,7 +24636,7 @@ var init_dist3 = __esm({
        *
        * 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).
+       * respectively.
        */
       computeContentHash(patchContent) {
         const lines = patchContent.split("\n");
@@ -25036,8 +24646,8 @@ var init_dist3 = __esm({
         return `sha256:${(0, import_crypto.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
+       * 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
@@ -25062,8 +24672,8 @@ var init_dist3 = __esm({
        * 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.
+       * preserves today's behaviour. Revisit if a future adversarial test
+       * demands per-file stripping.
        */
       async collapseNetZeroFiles(patches) {
         if (patches.length === 0) return patches;
@@ -25124,12 +24734,10 @@ var init_dist3 = __esm({
           firstParent,
           mergeCommit.sha
         ]);
-        const allMergeFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
-        const sensitiveMergeFiles = allMergeFiles.filter((f) => isSensitiveFile(f));
-        const files = allMergeFiles.filter((f) => !isSensitiveFile(f));
-        if (sensitiveMergeFiles.length > 0) {
+        const { files, sensitiveFiles } = filterInfrastructureAndSensitiveFiles(filesOutput);
+        if (sensitiveFiles.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.`
+            `Sensitive file(s) excluded from merge patch for commit ${mergeCommit.sha.slice(0, 7)}: ${sensitiveFiles.join(", ")}. These files will not be tracked by replay.`
           );
         }
         if (files.length === 0) return null;
@@ -25145,12 +24753,7 @@ var init_dist3 = __esm({
         if (lock.patches.some((p2) => p2.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
           return null;
         }
-        const theirsSnapshot = {};
-        for (const file of files) {
-          if (isBinaryFile(file)) continue;
-          const content = await this.git.showFile(mergeCommit.sha, file).catch(() => null);
-          if (content != null) theirsSnapshot[file] = content;
-        }
+        const theirsSnapshot = await capturePatchSnapshot(this.git, files, mergeCommit.sha);
         return {
           id: `patch-merge-${mergeCommit.sha.slice(0, 8)}`,
           content_hash: contentHash,
@@ -25174,13 +24777,24 @@ var init_dist3 = __esm({
         if (!diffBase) {
           return this.detectPatchesViaCommitScan();
         }
+        const lockForGuard = this.lockManager.read();
+        const knownGenerations = new Set(lockForGuard.generations.map((g) => g.commit_sha));
+        let resolvedBaseGeneration = commitKnownMissing ? diffBase : lastGen.commit_sha;
+        if (commitKnownMissing && !knownGenerations.has(diffBase)) {
+          const fallback = lockForGuard.current_generation ?? lockForGuard.generations[lockForGuard.generations.length - 1]?.commit_sha;
+          if (!fallback) {
+            this.warnings.push(
+              `Composite-patch fallback skipped: diff base ${diffBase.slice(0, 7)} is not a recorded generation and the lockfile has no recorded generations to anchor on. Customer customizations on disk are preserved; tracked patches will resume on the next regeneration.`
+            );
+            return { patches: [], revertedPatchIds: [] };
+          }
+          resolvedBaseGeneration = fallback;
+        }
         const filesOutput = await this.git.exec(["diff", "--name-only", diffBase, "HEAD"]);
-        const allTreeFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
-        const sensitiveTreeFiles = allTreeFiles.filter((f) => isSensitiveFile(f));
-        const files = allTreeFiles.filter((f) => !isSensitiveFile(f));
-        if (sensitiveTreeFiles.length > 0) {
+        const { files, sensitiveFiles } = filterInfrastructureAndSensitiveFiles(filesOutput);
+        if (sensitiveFiles.length > 0) {
           this.warnings.push(
-            `Sensitive file(s) excluded from composite patch: ${sensitiveTreeFiles.join(", ")}. These files will not be tracked by replay.`
+            `Sensitive file(s) excluded from composite patch: ${sensitiveFiles.join(", ")}. These files will not be tracked by replay.`
           );
         }
         if (files.length === 0) return { patches: [], revertedPatchIds: [] };
@@ -25192,21 +24806,19 @@ var init_dist3 = __esm({
           return { patches: [], revertedPatchIds: [] };
         }
         const headSha = (await this.git.exec(["rev-parse", "HEAD"])).trim();
-        const theirsSnapshot = {};
-        for (const file of files) {
-          if (isBinaryFile(file)) continue;
-          const content = await this.git.showFile("HEAD", file).catch(() => null);
-          if (content != null) theirsSnapshot[file] = content;
-        }
+        const theirsSnapshot = await capturePatchSnapshot(this.git, files, "HEAD");
         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,
+          // Anchor `base_generation` on a SHA the applicator's
+          // `resolveBaseGeneration` can find — always a member of
+          // `lock.generations`. When `diffBase` is a recorded
+          // generation, use it directly; otherwise the guard above
+          // has already mapped it onto `current_generation`.
+          base_generation: resolvedBaseGeneration,
           files,
           patch_content: diff,
           ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {},
@@ -25224,6 +24836,8 @@ var init_dist3 = __esm({
        */
       async detectPatchesViaCommitScan() {
         const lock = this.lockManager.read();
+        const knownGenerations = new Set(lock.generations.map((g) => g.commit_sha));
+        const fallbackAnchor = lock.current_generation ?? lock.generations[lock.generations.length - 1]?.commit_sha;
         const log = await this.git.exec([
           "log",
           "--max-count=200",
@@ -25265,12 +24879,10 @@ var init_dist3 = __esm({
             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((f) => !INFRASTRUCTURE_FILES.has(f));
-          const sensitiveScanFiles = allScanFiles.filter((f) => isSensitiveFile(f));
-          const files = allScanFiles.filter((f) => !isSensitiveFile(f));
-          if (sensitiveScanFiles.length > 0) {
+          const { files, sensitiveFiles } = filterInfrastructureAndSensitiveFiles(filesOutput);
+          if (sensitiveFiles.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.`
+              `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) {
               if (parents.length === 0) {
@@ -25292,19 +24904,25 @@ var init_dist3 = __esm({
             continue;
           }
           const parentSha = parents[0];
-          const theirsSnapshot = {};
-          for (const file of files) {
-            if (isBinaryFile(file)) continue;
-            const content = await this.git.showFile(commit.sha, file).catch(() => null);
-            if (content != null) theirsSnapshot[file] = content;
+          let baseGeneration;
+          if (knownGenerations.has(parentSha)) {
+            baseGeneration = parentSha;
+          } else if (fallbackAnchor) {
+            baseGeneration = fallbackAnchor;
+          } else {
+            this.warnings.push(
+              `Skipping commit ${commit.sha.slice(0, 7)} (${commit.message.split("\n")[0]}): no recorded generation in the lockfile to anchor on. The customer's state on disk is preserved; tracked patches will resume on the next regeneration.`
+            );
+            continue;
           }
+          const theirsSnapshot = await capturePatchSnapshot(this.git, files, commit.sha);
           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,
+            base_generation: baseGeneration,
             files,
             patch_content: patchContent,
             ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {}
@@ -25349,6 +24967,541 @@ var init_dist3 = __esm({
         return lock.generations.find((g) => g.commit_sha === lock.current_generation);
       }
     };
+    MergeAccumulator = class {
+      constructor(mode, sharedFiles) {
+        this.mode = mode;
+        this.sharedFiles = sharedFiles;
+      }
+      entries = /* @__PURE__ */ new Map();
+      /** Was this file touched by 2+ patches in the current `applyPatches` invocation? */
+      isShared(path5) {
+        return this.sharedFiles.has(path5);
+      }
+      /** Has any prior patch already recorded a result for this path? */
+      has(path5) {
+        return this.entries.has(path5);
+      }
+      /** Look up the accumulated content + base generation for this path. */
+      lookup(path5) {
+        return this.entries.get(path5);
+      }
+      /**
+       * True if any of the patch's files have a prior accumulator entry — in
+       * which case the fast path (`git apply --3way`) cannot honor prior
+       * patches' contributions and we must route through the slow path.
+       */
+      shouldSkipFastPath(patch) {
+        return patch.files.some((f) => this.entries.has(f));
+      }
+      /** Record a successful (clean) merge result. */
+      recordMerge(path5, content, baseGeneration) {
+        this.entries.set(path5, { content, baseGeneration });
+      }
+      /**
+       * Record a conflicted merge result. Populates only in `"resolve"` mode
+       * — replay mode keeps the accumulator clean of marker-laden content
+       * since markers will be stripped from disk after the apply loop.
+       */
+      recordConflict(path5, content, baseGeneration) {
+        if (this.mode === "resolve") {
+          this.entries.set(path5, { content, baseGeneration });
+        }
+      }
+      /**
+       * Defensive copy for test introspection. Used by invariant I2 to assert
+       * that after every applied patch, the accumulator has an entry for each
+       * file the patch touched (see `__tests__/invariants/i2-accumulator-correctness.ts`).
+       *
+       * @internal
+       */
+      snapshot() {
+        const copy = /* @__PURE__ */ new Map();
+        for (const [path5, entry] of this.entries) {
+          copy.set(path5, { content: entry.content, baseGeneration: entry.baseGeneration });
+        }
+        return copy;
+      }
+    };
+    CONFLICT_OPENER = "<<<<<<< Generated";
+    CONFLICT_SEPARATOR = "=======";
+    CONFLICT_CLOSER = ">>>>>>> Your customization";
+    ReplayApplicator = class {
+      git;
+      lockManager;
+      outputDir;
+      renameCache = /* @__PURE__ */ new Map();
+      treeExistsCache = /* @__PURE__ */ new Map();
+      /**
+       * Inter-patch THEIRS coordination. Created fresh in each `applyPatches`
+       * invocation with the run's apply mode + precomputed shared-file set.
+       * See `src/accumulator/MergeAccumulator.ts` for the full contract.
+       *
+       * Initialized to an empty default in the constructor so type narrowing
+       * works for callers that read it before any `applyPatches` invocation
+       * (e.g., the `getAccumulatorSnapshot` test accessor).
+       */
+      accumulator = new MergeAccumulator("replay", /* @__PURE__ */ new Set());
+      constructor(git, lockManager, outputDir) {
+        this.git = git;
+        this.lockManager = lockManager;
+        this.outputDir = outputDir;
+      }
+      /**
+       * Resolve the GenerationRecord for a patch's base_generation.
+       * Falls back to constructing an ad-hoc record from the commit's tree
+       * when base_generation isn't a tracked generation (commit-scan patches).
+       */
+      async resolveBaseGeneration(baseGeneration) {
+        const gen = this.lockManager.getGeneration(baseGeneration);
+        if (gen) return gen;
+        try {
+          const treeHash = await this.git.getTreeHash(baseGeneration);
+          return {
+            commit_sha: baseGeneration,
+            tree_hash: treeHash,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            cli_version: "unknown",
+            generator_versions: {}
+          };
+        } catch {
+          return void 0;
+        }
+      }
+      /**
+       * @internal Test-only.
+       * Returns a defensive copy of the inter-patch accumulator. Used by
+       * invariant I2 to assert that after every applied patch, the
+       * accumulator has an entry for each file the patch touched, and the
+       * entry's content matches on-disk.
+       */
+      getAccumulatorSnapshot() {
+        return this.accumulator.snapshot();
+      }
+      /**
+       * Apply all patches, returning results for each.
+       * Skips patches that match exclude patterns in replay.yml
+       *
+       * `applyMode` controls the post-conflict marker strategy:
+       *   - `"replay"` (default): strip conflict markers from disk between
+       *     iterations whenever a later patch touches the same file. Lets the
+       *     follow-up patch's `git apply --3way` see clean OURS content,
+       *     which is what the silent-loss fix (PR #73) relies on. The replay
+       *     pipeline calls `revertConflictingFiles` after the loop to clean
+       *     any markers that survive.
+       *   - `"resolve"`: keep markers on disk. The resolve command needs the
+       *     customer to see them. Slow-path 3-way merge naturally preserves
+       *     A's markers and B's clean writes when their regions don't overlap;
+       *     when they do overlap, the customer gets nested markers and
+       *     resolves manually. Either way they aren't silently dropped.
+       */
+      async applyPatches(patches, opts) {
+        const applyMode = opts?.applyMode ?? "replay";
+        const fileFreq = /* @__PURE__ */ new Map();
+        for (const p2 of patches) {
+          for (const f of p2.files) {
+            fileFreq.set(f, (fileFreq.get(f) ?? 0) + 1);
+          }
+        }
+        const sharedFiles = new Set(
+          Array.from(fileFreq.entries()).filter(([, n]) => n > 1).map(([f]) => f)
+        );
+        this.accumulator = new MergeAccumulator(applyMode, sharedFiles);
+        const results = [];
+        for (let i2 = 0; i2 < patches.length; i2++) {
+          const patch = patches[i2];
+          if (this.isExcluded(patch)) {
+            results.push({
+              patch,
+              status: "skipped",
+              method: "git-am"
+            });
+            continue;
+          }
+          const result = await this.applyPatchWithFallback(patch);
+          results.push(result);
+          if (applyMode !== "resolve" && result.status === "conflict" && result.fileResults) {
+            const laterFiles = /* @__PURE__ */ new Set();
+            for (let j2 = i2 + 1; j2 < patches.length; j2++) {
+              for (const f of patches[j2].files) {
+                laterFiles.add(f);
+              }
+            }
+            const resolvedToOriginal = /* @__PURE__ */ new Map();
+            if (result.resolvedFiles) {
+              for (const [orig, resolved] of Object.entries(result.resolvedFiles)) {
+                resolvedToOriginal.set(resolved, orig);
+              }
+            }
+            for (const fileResult of result.fileResults) {
+              if (fileResult.status !== "conflict") continue;
+              const originalPath = resolvedToOriginal.get(fileResult.file) ?? fileResult.file;
+              if (laterFiles.has(fileResult.file) || laterFiles.has(originalPath)) {
+                const filePath = (0, import_path10.join)(this.outputDir, fileResult.file);
+                try {
+                  const content = await (0, import_promises4.readFile)(filePath, "utf-8");
+                  const stripped = stripConflictMarkers(content);
+                  await (0, import_promises4.writeFile)(filePath, stripped);
+                } catch {
+                }
+              }
+            }
+          }
+        }
+        return results;
+      }
+      /**
+       * Populate accumulator after git apply succeeds, AND collect per-file
+       * results including any "dropped context lines" — lines that were
+       * present in BASE and THEIRS (unchanged context) but absent from the
+       * final on-disk state because OURS deleted them. This is the fast-path
+       * counterpart to ThreeWayMerge.computeDroppedContextLines used by the
+       * 3-way slow path; both must surface the same warning.
+       */
+      async populateAccumulatorForPatch(patch, baseGen, currentTreeHash) {
+        const fileResults = [];
+        if (!baseGen) return fileResults;
+        const tempDir = await (0, import_promises4.mkdtemp)((0, import_path10.join)((0, import_os2.tmpdir)(), "replay-acc-"));
+        const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
+        const tempGit = new GitClient2(tempDir);
+        await tempGit.exec(["init"]);
+        await tempGit.exec(["config", "user.email", "replay@fern.com"]);
+        await tempGit.exec(["config", "user.name", "Fern Replay"]);
+        try {
+          for (const filePath of patch.files) {
+            if (isBinaryFile(filePath)) continue;
+            const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
+            const base = await this.git.showFile(baseGen.tree_hash, filePath);
+            const snapshotForFile = patch.theirs_snapshot?.[resolvedPath] ?? patch.theirs_snapshot?.[filePath];
+            const fileIsShared = this.accumulator.isShared(resolvedPath) || this.accumulator.isShared(filePath);
+            const theirs = !fileIsShared && snapshotForFile != null ? snapshotForFile : await this.applyPatchToContent(base, patch.patch_content, filePath, tempGit, tempDir);
+            const finalOnDisk = await (0, import_promises4.readFile)((0, import_path10.join)(this.outputDir, resolvedPath), "utf-8").catch(() => null);
+            const effectiveTheirs = theirs ?? finalOnDisk;
+            if (effectiveTheirs != null) {
+              this.accumulator.recordMerge(resolvedPath, effectiveTheirs, patch.base_generation);
+            }
+            if (base != null && effectiveTheirs != null && finalOnDisk != null) {
+              const dropped = computeDroppedContextLinesForFile(base, effectiveTheirs, finalOnDisk);
+              if (dropped.length > 0) {
+                fileResults.push({
+                  file: resolvedPath,
+                  status: "merged",
+                  droppedContextLines: dropped
+                });
+              }
+            }
+          }
+        } finally {
+          await (0, import_promises4.rm)(tempDir, { recursive: true }).catch(() => {
+          });
+        }
+        return fileResults;
+      }
+      async applyPatchWithFallback(patch) {
+        const baseGen = await this.resolveBaseGeneration(patch.base_generation);
+        const lock = this.lockManager.read();
+        const currentGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
+        const currentTreeHash = currentGen?.tree_hash ?? baseGen?.tree_hash ?? "";
+        const needsAccumulation = await Promise.all(
+          patch.files.map(async (f) => {
+            if (!baseGen) return false;
+            const resolved = await this.resolveFilePath(f, baseGen.tree_hash, currentTreeHash);
+            return this.accumulator.has(resolved);
+          })
+        ).then((results) => results.some(Boolean));
+        const resolvedFiles = {};
+        for (const filePath of patch.files) {
+          const resolvedPath = baseGen ? await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash) : filePath;
+          if (resolvedPath !== filePath) {
+            resolvedFiles[filePath] = resolvedPath;
+          }
+        }
+        const patchIsRenameAware = /^rename from /m.test(patch.patch_content);
+        const hasGeneratorRename = Object.keys(resolvedFiles).length > 0 && !patchIsRenameAware;
+        if (!needsAccumulation && !hasGeneratorRename) {
+          const snapshots = /* @__PURE__ */ new Map();
+          for (const filePath of patch.files) {
+            const fullPath = (0, import_path10.join)(this.outputDir, filePath);
+            snapshots.set(filePath, await (0, import_promises4.readFile)(fullPath, "utf-8").catch(() => null));
+          }
+          try {
+            await this.git.execWithInput(["apply", "--3way"], patch.patch_content);
+            const fastPathFileResults = await this.populateAccumulatorForPatch(patch, baseGen, currentTreeHash);
+            return {
+              patch,
+              status: "applied",
+              method: "git-am",
+              ...fastPathFileResults.length > 0 && { fileResults: fastPathFileResults },
+              ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
+            };
+          } catch {
+            for (const [filePath, content] of snapshots) {
+              const fullPath = (0, import_path10.join)(this.outputDir, filePath);
+              if (content != null) {
+                await (0, import_promises4.writeFile)(fullPath, content);
+              } else {
+                await (0, import_promises4.unlink)(fullPath).catch(() => {
+                });
+              }
+            }
+          }
+        }
+        return this.applyWithThreeWayMerge(patch);
+      }
+      async applyWithThreeWayMerge(patch) {
+        const fileResults = [];
+        const resolvedFiles = {};
+        const tempDir = await (0, import_promises4.mkdtemp)((0, import_path10.join)((0, import_os2.tmpdir)(), "replay-"));
+        const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
+        const tempGit = new GitClient2(tempDir);
+        await tempGit.exec(["init"]);
+        await tempGit.exec(["config", "user.email", "replay@fern.com"]);
+        await tempGit.exec(["config", "user.name", "Fern Replay"]);
+        try {
+          for (const filePath of patch.files) {
+            if (isBinaryFile(filePath)) {
+              fileResults.push({
+                file: filePath,
+                status: "skipped",
+                reason: "binary-file"
+              });
+              continue;
+            }
+            const result = await this.mergeFile(patch, filePath, tempGit, tempDir);
+            if (result.file !== filePath) {
+              resolvedFiles[filePath] = result.file;
+            }
+            fileResults.push(result);
+          }
+        } finally {
+          await (0, import_promises4.rm)(tempDir, { recursive: true }).catch(() => {
+          });
+        }
+        const conflictFiles = fileResults.filter((r2) => r2.status === "conflict");
+        const hasConflicts = conflictFiles.length > 0;
+        const conflictReason = hasConflicts ? conflictFiles.some((f) => f.conflictReason === "base-generation-mismatch") ? "base-generation-mismatch" : conflictFiles[0]?.conflictReason : void 0;
+        return {
+          patch,
+          status: hasConflicts ? "conflict" : "applied",
+          method: "3way-merge",
+          fileResults,
+          conflictReason,
+          ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
+        };
+      }
+      async mergeFile(patch, filePath, tempGit, tempDir) {
+        try {
+          const inputs = await resolveInputs({
+            patch,
+            filePath,
+            git: this.git,
+            lockManager: this.lockManager,
+            outputDir: this.outputDir,
+            isTreeReachable: (h2) => this.isTreeReachable(h2),
+            resolveBaseGeneration: (s) => this.resolveBaseGeneration(s),
+            resolveFilePath: (f, b3, c3) => this.resolveFilePath(f, b3, c3),
+            extractRenameSource: (p2, f) => this.extractRenameSource(p2, f),
+            extractFileDiff: (p2, f) => this.extractFileDiff(p2, f)
+          });
+          if (inputs.earlyExit) {
+            return { file: filePath, ...inputs.earlyExit };
+          }
+          const plan = await buildMergePlan({
+            inputs,
+            patch,
+            filePath,
+            accumulator: this.accumulator,
+            tempGit,
+            tempDir,
+            applyPatchToContent: (b3, p2, f, g, d, s) => this.applyPatchToContent(b3, p2, f, g, d, s),
+            isPatchAlreadyApplied: (p2, f, c3, g, d) => this.isPatchAlreadyApplied(p2, f, c3, g, d)
+          });
+          return await runMergeAndRecord({
+            plan,
+            inputs,
+            patch,
+            accumulator: this.accumulator
+          });
+        } catch (error) {
+          return {
+            file: filePath,
+            status: "skipped",
+            reason: `error: ${error instanceof Error ? error.message : String(error)}`
+          };
+        }
+      }
+      async isTreeReachable(treeHash) {
+        let result = this.treeExistsCache.get(treeHash);
+        if (result === void 0) {
+          result = await this.git.treeExists(treeHash);
+          this.treeExistsCache.set(treeHash, result);
+        }
+        return result;
+      }
+      isExcluded(patch) {
+        const config = this.lockManager.getCustomizationsConfig();
+        if (!config.exclude) return false;
+        return patch.files.some((file) => config.exclude.some((pattern) => minimatch(file, pattern)));
+      }
+      async resolveFilePath(filePath, baseTreeHash, currentTreeHash) {
+        const config = this.lockManager.getCustomizationsConfig();
+        if (config.moves) {
+          for (const move of config.moves) {
+            if (minimatch(filePath, move.from) || filePath === move.from) {
+              if (filePath === move.from) {
+                return move.to;
+              }
+              const fromBase = move.from.replace(/\*\*.*$/, "");
+              const toBase = move.to.replace(/\*\*.*$/, "");
+              if (filePath.startsWith(fromBase)) {
+                return toBase + filePath.slice(fromBase.length);
+              }
+            }
+          }
+        }
+        const cacheKey = `${baseTreeHash}:${currentTreeHash}`;
+        let renames = this.renameCache.get(cacheKey);
+        if (!renames) {
+          renames = await this.git.detectRenames(baseTreeHash, currentTreeHash);
+          this.renameCache.set(cacheKey, renames);
+        }
+        const gitRename = renames.find((r2) => r2.from === filePath);
+        if (gitRename) {
+          return gitRename.to;
+        }
+        return filePath;
+      }
+      async applyPatchToContent(base, patchContent, filePath, tempGit, tempDir, sourceFilePath) {
+        if (!base) {
+          return this.extractNewFileFromPatch(patchContent, filePath);
+        }
+        const fileDiff = this.extractFileDiff(patchContent, filePath);
+        if (!fileDiff) return null;
+        try {
+          if (sourceFilePath) {
+            const tempSourcePath = (0, import_path10.join)(tempDir, sourceFilePath);
+            await (0, import_promises4.mkdir)((0, import_path10.dirname)(tempSourcePath), { recursive: true });
+            await (0, import_promises4.writeFile)(tempSourcePath, base);
+            await tempGit.exec(["add", sourceFilePath]);
+            await tempGit.exec([
+              "commit",
+              "-m",
+              `base for rename ${sourceFilePath} -> ${filePath}`,
+              "--allow-empty"
+            ]);
+            await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
+            const tempTargetPath = (0, import_path10.join)(tempDir, filePath);
+            return await (0, import_promises4.readFile)(tempTargetPath, "utf-8");
+          }
+          const tempFilePath = (0, import_path10.join)(tempDir, filePath);
+          await (0, import_promises4.mkdir)((0, import_path10.dirname)(tempFilePath), { recursive: true });
+          await (0, import_promises4.writeFile)(tempFilePath, base);
+          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_promises4.readFile)(tempFilePath, "utf-8");
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Detects whether a patch's additions are already present in `content`.
+       * Uses `git apply --reverse --check` — if the reverse patch applies cleanly,
+       * the forward patch is effectively a no-op (its +lines are already there and
+       * its -lines are already gone). Used to distinguish "patch already applied"
+       * from "patch base mismatch" after a forward-apply fails.
+       */
+      async isPatchAlreadyApplied(patchContent, filePath, content, tempGit, tempDir) {
+        const fileDiff = this.extractFileDiff(patchContent, filePath);
+        if (!fileDiff) return false;
+        try {
+          const tempFilePath = (0, import_path10.join)(tempDir, filePath);
+          await (0, import_promises4.mkdir)((0, import_path10.dirname)(tempFilePath), { recursive: true });
+          await (0, import_promises4.writeFile)(tempFilePath, content);
+          await tempGit.exec(["add", filePath]);
+          await tempGit.exec(["commit", "-m", `check already-applied ${filePath}`, "--allow-empty"]);
+          await tempGit.execWithInput(["apply", "--reverse", "--check", "--allow-empty"], fileDiff);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      extractFileDiff(patchContent, filePath) {
+        const lines = patchContent.split("\n");
+        const diffLines = [];
+        let inTargetFile = false;
+        for (const line of lines) {
+          if (line.startsWith("diff --git")) {
+            if (inTargetFile) {
+              break;
+            }
+            if (isDiffLineForFile(line, filePath)) {
+              inTargetFile = true;
+              diffLines.push(line);
+            }
+            continue;
+          }
+          if (inTargetFile) {
+            diffLines.push(line);
+          }
+        }
+        return diffLines.length > 0 ? diffLines.join("\n") + "\n" : null;
+      }
+      extractRenameSource(patchContent, targetFilePath) {
+        const lines = patchContent.split("\n");
+        let inTargetFile = false;
+        for (const line of lines) {
+          if (line.startsWith("diff --git")) {
+            if (inTargetFile) break;
+            inTargetFile = isDiffLineForFile(line, targetFilePath);
+            continue;
+          }
+          if (!inTargetFile) continue;
+          if (line.startsWith("@@")) break;
+          if (line.startsWith("rename from ")) {
+            return line.slice("rename from ".length);
+          }
+        }
+        return null;
+      }
+      extractNewFileFromPatch(patchContent, filePath) {
+        const lines = patchContent.split("\n");
+        const addedLines = [];
+        let inTargetFile = false;
+        let inHunk = false;
+        let isNewFile = false;
+        let noTrailingNewline = false;
+        for (const line of lines) {
+          if (line.startsWith("diff --git")) {
+            if (inTargetFile) break;
+            inTargetFile = isDiffLineForFile(line, filePath);
+            inHunk = false;
+            isNewFile = false;
+            continue;
+          }
+          if (!inTargetFile) continue;
+          if (!inHunk) {
+            if (line === "--- /dev/null" || line.startsWith("new file mode")) {
+              isNewFile = true;
+            }
+          }
+          if (line.startsWith("@@")) {
+            if (!isNewFile) return null;
+            inHunk = true;
+            continue;
+          }
+          if (!inHunk) continue;
+          if (line === "\") {
+            noTrailingNewline = true;
+            continue;
+          }
+          if (line.startsWith("+") && !line.startsWith("+++")) {
+            addedLines.push(line.slice(1));
+          }
+        }
+        if (addedLines.length === 0) return null;
+        return addedLines.join("\n") + (noTrailingNewline ? "" : "\n");
+      }
+    };
     ReplayCommitter = class {
       git;
       outputDir;
@@ -25452,210 +25605,66 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
     };
     init_GitClient();
     init_HybridReconstruction();
-    ReplayService = class {
-      git;
-      detector;
-      applicator;
-      committer;
-      lockManager;
-      outputDir;
-      /** @internal Test-only. Captures the last ReplayResult[] returned from applicator.applyPatches(). */
-      _lastApplyResults = [];
-      /**
-       * Service-level warnings accumulated during a single runReplay() call.
-       * Merged with `detector.warnings` into `ReplayReport.warnings` by each flow handler.
-       * Populated by `isFileUserOwned` when a patch's base generation tree is unreachable
-       * (shallow clone / aggressive `git gc --prune`) and we fall back to a conservative
-       * heuristic. Cleared at the top of `runReplay()`.
-       */
-      warnings = [];
-      /**
-       * @internal Test-only accessor.
-       * Returns the ReplayApplicator instance used for the last run. Tests use this
-       * to inspect the inter-patch accumulator after runReplay() completes (FER-9791, I2).
-       */
-      get applicatorRef() {
-        return this.applicator;
-      }
-      /**
-       * @internal Test-only accessor.
-       * Returns the ReplayResult[] from the most recent applyPatches() call. Tests use
-       * this to filter applied-vs-conflicted-vs-absorbed patches for invariant assertions
-       * (FER-9791). Returns an empty array if no patches have been applied yet.
-       */
-      getLastResults() {
-        return this._lastApplyResults;
-      }
-      constructor(outputDir, _config) {
-        const git = new GitClient(outputDir);
+    FileOwnership = class {
+      constructor(git) {
         this.git = git;
-        this.outputDir = outputDir;
-        this.lockManager = new LockfileManager(outputDir);
-        this.detector = new ReplayDetector(git, this.lockManager, outputDir);
-        this.applicator = new ReplayApplicator(git, this.lockManager, outputDir);
-        this.committer = new ReplayCommitter(git, outputDir);
-      }
-      /**
-       * Phase 1 of the two-phase replay flow. Runs preGenerationRebase (when applicable),
-       * detects new patches, and creates the `[fern-generated]` commit. Leaves HEAD at
-       * the generation commit (or unchanged for dry-run).
-       *
-       * Does NOT apply patches — the returned handle must be passed to
-       * `applyPreparedReplay()` to complete the run. No disk writes to the lockfile
-       * happen here; lockfile persistence is deferred to phase 2.
-       *
-       * Callers may land additional commits on HEAD between `prepareReplay` and
-       * `applyPreparedReplay` (e.g., `[fern-autoversion]`).
-       */
-      async prepareReplay(options) {
-        this.warnings = [];
-        this.detector.warnings.length = 0;
-        if (options?.skipApplication) {
-          return this._prepareSkipApplication(options);
-        }
-        const flow = this.determineFlow();
-        switch (flow) {
-          case "first-generation":
-            return this._prepareFirstGeneration(options);
-          case "no-patches":
-            return this._prepareNoPatchesRegeneration(options);
-          case "normal-regeneration":
-            return this._prepareNormalRegeneration(options);
-        }
       }
       /**
-       * Phase 2 of the two-phase replay flow. Applies patches, rebases them against
-       * the generation, saves the lockfile, and commits `[fern-replay]` (or stages
-       * under `stageOnly`). Operates on HEAD at call time — mid-phase commits are
-       * respected.
+       * Canonical resolution. Returns true if `file` is user-owned per:
        *
-       * For terminal handles (dry-run, first-gen has no patch work, skip-app does
-       * its own post-commit logic), this returns the precomputed report.
+       *   1. `patch.user_owned === true` — authoritative, persisted flag.
+       *   2. `file === ".fernignore"` — always user-owned.
+       *   3. File matches a `.fernignore` pattern (via minimatch).
+       *   4. Patch content shows `--- /dev/null` for this file (legacy-safe
+       *      signal for patches predating `user_owned` or whose flag was lost).
+       *   5. Tree-based check against `patch.base_generation` when reachable
+       *      AND distinct from `currentGenSha`. Unreachable base → conservative
+       *      user-owned (silent-absorption safety net), with a one-time warning
+       *      per base SHA.
+       *   6. Final fallback: check `currentGenSha` when no usable base exists
+       *      (legacy one-gen lockfile).
        */
-      async applyPreparedReplay(prep, options) {
-        if (prep._prepared.terminal) {
-          return prep._prepared.preparedReport;
-        }
-        switch (prep._prepared.flow) {
-          case "first-generation":
-            return this._applyFirstGeneration(prep);
-          case "skip-application":
-            return this._applySkipApplication(prep, options);
-          case "no-patches":
-            return this._applyNoPatchesRegeneration(prep, options);
-          case "normal-regeneration":
-            return this._applyNormalRegeneration(prep, options);
-        }
-      }
-      /**
-       * Backwards-compatible atomic entry point. Composes `prepareReplay` + `applyPreparedReplay`.
-       * Behavior is byte-identical to the pre-split implementation for all existing callers.
-       */
-      async runReplay(options) {
-        const prep = await this.prepareReplay(options);
-        return this.applyPreparedReplay(prep, options);
-      }
-      /**
-       * Sync the lockfile after a divergent PR was squash-merged.
-       * Call this BEFORE runReplay() when the CLI detects a merged divergent PR.
-       *
-       * After updating the generation record, re-detects customer patches via
-       * tree diff between the generation tag (pure generation tree) and HEAD
-       * (which includes customer customizations after squash merge). This ensures
-       * patches survive the squash merge → regenerate cycle even when the lockfile
-       * was restored from the base branch during conflict PR creation.
-       */
-      async syncFromDivergentMerge(generationCommitSha, options) {
-        const treeHash = await this.git.getTreeHash(generationCommitSha);
-        const timestamp = (await this.git.exec(["log", "-1", "--format=%aI", generationCommitSha])).trim();
-        const record2 = {
-          commit_sha: generationCommitSha,
-          tree_hash: treeHash,
-          timestamp,
-          cli_version: options?.cliVersion ?? "unknown",
-          generator_versions: options?.generatorVersions ?? {},
-          base_branch_head: options?.baseBranchHead
-        };
-        let resolvedPatches;
-        if (!this.lockManager.exists()) {
-          this.lockManager.initializeInMemory(record2);
-        } else {
-          this.lockManager.read();
-          const unresolvedPatches = [
-            ...this.lockManager.getUnresolvedPatches(),
-            ...this.lockManager.getResolvingPatches()
-          ];
-          resolvedPatches = this.lockManager.getPatches().filter((p2) => p2.status == null);
-          this.lockManager.addGeneration(record2);
-          this.lockManager.clearPatches();
-          for (const patch of unresolvedPatches) {
-            this.lockManager.addPatch(patch);
-          }
+      async resolveCanonical(ctx) {
+        const { file, originalFileName, patch, currentGenSha, fernignorePatterns, warnedGens, warnings } = ctx;
+        if (patch.user_owned) return true;
+        if (file === ".fernignore") return true;
+        if (fernignorePatterns.some((p2) => file === p2 || minimatch(file, p2))) return true;
+        if (fileIsCreationInPatchContent(patch.patch_content, originalFileName ?? file)) {
+          return true;
         }
-        try {
-          const { patches: redetectedPatches } = await this.detector.detectNewPatches();
-          if (redetectedPatches.length > 0) {
-            const redetectedFiles = new Set(redetectedPatches.flatMap((p2) => p2.files));
-            const currentPatches = this.lockManager.getPatches();
-            for (const patch of currentPatches) {
-              if (patch.status != null && patch.files.some((f) => redetectedFiles.has(f))) {
-                this.lockManager.removePatch(patch.id);
-              }
-            }
-            for (const patch of redetectedPatches) {
-              this.lockManager.addPatch(patch);
+        const base = patch.base_generation;
+        if (base && base !== currentGenSha) {
+          const reachable = await this.git.commitExists(base) || await this.git.treeExists(base);
+          if (!reachable) {
+            if (!warnedGens.has(base)) {
+              warnedGens.add(base);
+              warnings.push(
+                `Base generation ${base.slice(0, 7)} is unreachable (shallow clone or pruned history). Treating affected files as user-owned to avoid silent data loss. Run \`git fetch --unshallow\` or avoid \`git gc --prune\` to restore full history.`
+              );
             }
+            return true;
           }
-        } catch (error) {
-          for (const patch of resolvedPatches ?? []) {
-            this.lockManager.addPatch(patch);
-          }
-          this.detector.warnings.push(
-            `Patch re-detection failed after divergent merge sync. ${(resolvedPatches ?? []).length} previously resolved patch(es) preserved. Error: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-        this.lockManager.save();
-        this.detector.warnings.push(...this.lockManager.warnings);
-      }
-      determineFlow() {
-        try {
-          const lock = this.lockManager.read();
-          return lock.patches.length === 0 ? "no-patches" : "normal-regeneration";
-        } catch (error) {
-          if (error instanceof LockfileNotFoundError) {
-            return "first-generation";
-          }
-          throw error;
+          return await this.git.showFile(base, originalFileName ?? file) === null;
         }
+        return await this.git.showFile(currentGenSha, originalFileName ?? file) === null;
       }
-      firstGenerationReport() {
-        return {
-          flow: "first-generation",
-          patchesDetected: 0,
-          patchesApplied: 0,
-          patchesWithConflicts: 0,
-          patchesSkipped: 0,
-          conflicts: []
-        };
+    };
+    FirstGenerationFlow = class {
+      constructor(service) {
+        this.service = service;
       }
-      async _prepareFirstGeneration(options) {
+      async prepare(options) {
         if (options?.dryRun) {
-          const headSha = await this.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
+          const headSha = await this.service.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
           return {
             flow: "first-generation",
             previousGenerationSha: null,
             currentGenerationSha: headSha,
             baseBranchHead: options.baseBranchHead ?? null,
             _prepared: {
+              kind: "terminal",
               flow: "first-generation",
-              terminal: true,
-              preparedReport: this.firstGenerationReport(),
-              patchesToApply: [],
-              newPatchIds: /* @__PURE__ */ new Set(),
-              detectorWarnings: [],
-              revertedCount: 0,
-              genSha: headSha,
-              optionsSnapshot: options
+              preparedReport: firstGenerationReport()
             }
           };
         }
@@ -25664,17 +25673,17 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
           generatorVersions: options.generatorVersions ?? {},
           baseBranchHead: options.baseBranchHead
         } : void 0;
-        await this.committer.commitGeneration("Initial SDK generation", commitOpts);
-        const genRecord = await this.committer.createGenerationRecord(commitOpts);
-        this.lockManager.initializeInMemory(genRecord);
+        await this.service.committer.commitGeneration("Initial SDK generation", commitOpts);
+        const genRecord = await this.service.committer.createGenerationRecord(commitOpts);
+        this.service.lockManager.initializeInMemory(genRecord);
         return {
           flow: "first-generation",
           previousGenerationSha: null,
           currentGenerationSha: genRecord.commit_sha,
           baseBranchHead: options?.baseBranchHead ?? null,
           _prepared: {
+            kind: "active",
             flow: "first-generation",
-            terminal: false,
             patchesToApply: [],
             newPatchIds: /* @__PURE__ */ new Set(),
             detectorWarnings: [],
@@ -25684,47 +25693,45 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
           }
         };
       }
-      async _applyFirstGeneration(_prep) {
-        this.lockManager.save();
-        return this.firstGenerationReport();
+      async apply(_prep) {
+        this.service.lockManager.save();
+        return firstGenerationReport();
       }
-      /**
-       * Skip-application mode phase 1: commit the generation and update the
-       * in-memory lockfile, but don't detect or apply patches. Sets a marker
-       * so the next normal run skips revert detection in preGenerationRebase().
-       *
-       * Disk save is deferred to `_applySkipApplication`.
-       */
-      async _prepareSkipApplication(options) {
+    };
+    SkipApplicationFlow = class {
+      constructor(service) {
+        this.service = service;
+      }
+      async prepare(options) {
         const commitOpts = options ? {
           cliVersion: options.cliVersion ?? "unknown",
           generatorVersions: options.generatorVersions ?? {},
           baseBranchHead: options.baseBranchHead
         } : void 0;
-        await this.committer.commitGeneration("Update SDK (replay skipped)", commitOpts);
-        await this.cleanupStaleConflictMarkers();
-        const genRecord = await this.committer.createGenerationRecord(commitOpts);
+        await this.service.committer.commitGeneration("Update SDK (replay skipped)", commitOpts);
+        await this.service.cleanupStaleConflictMarkers();
+        const genRecord = await this.service.committer.createGenerationRecord(commitOpts);
         let previousGenerationSha = null;
         try {
-          const lock = this.lockManager.read();
+          const lock = this.service.lockManager.read();
           previousGenerationSha = lock.current_generation ?? null;
-          this.lockManager.addGeneration(genRecord);
+          this.service.lockManager.addGeneration(genRecord);
         } catch (error) {
           if (error instanceof LockfileNotFoundError) {
-            this.lockManager.initializeInMemory(genRecord);
+            this.service.lockManager.initializeInMemory(genRecord);
           } else {
             throw error;
           }
         }
-        this.lockManager.setReplaySkippedAt((/* @__PURE__ */ new Date()).toISOString());
+        this.service.lockManager.setReplaySkippedAt((/* @__PURE__ */ new Date()).toISOString());
         return {
           flow: "skip-application",
           previousGenerationSha,
           currentGenerationSha: genRecord.commit_sha,
           baseBranchHead: options?.baseBranchHead ?? null,
           _prepared: {
+            kind: "active",
             flow: "skip-application",
-            terminal: false,
             patchesToApply: [],
             newPatchIds: /* @__PURE__ */ new Set(),
             detectorWarnings: [],
@@ -25734,13 +25741,13 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
           }
         };
       }
-      async _applySkipApplication(_prep, options) {
-        this.lockManager.save();
-        const credentialWarnings = [...this.lockManager.warnings];
+      async apply(_prep, options) {
+        this.service.lockManager.save();
+        const credentialWarnings = [...this.service.lockManager.warnings];
         if (!options?.stageOnly) {
-          await this.committer.commitReplay(0);
+          await this.service.committer.commitReplay(0);
         } else {
-          await this.committer.stageAll();
+          await this.service.committer.stageAll();
         }
         return {
           flow: "skip-application",
@@ -25752,13 +25759,18 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
           warnings: credentialWarnings.length > 0 ? credentialWarnings : void 0
         };
       }
-      async _prepareNoPatchesRegeneration(options) {
-        const preLock = this.lockManager.read();
+    };
+    NoPatchesFlow = class {
+      constructor(service) {
+        this.service = service;
+      }
+      async prepare(options) {
+        const preLock = this.service.lockManager.read();
         const previousGenerationSha = preLock.current_generation ?? null;
-        let { patches: newPatches, revertedPatchIds } = await this.detector.detectNewPatches();
-        const detectorWarnings = [...this.detector.warnings];
+        let { patches: newPatches, revertedPatchIds } = await this.service.detector.detectNewPatches();
+        const detectorWarnings = [...this.service.detector.warnings];
         if (options?.dryRun) {
-          const dryRunWarnings = [...detectorWarnings, ...this.warnings];
+          const dryRunWarnings = [...detectorWarnings, ...this.service.warnings];
           const preparedReport = {
             flow: "no-patches",
             patchesDetected: newPatches.length,
@@ -25770,22 +25782,16 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
             wouldApply: newPatches,
             warnings: dryRunWarnings.length > 0 ? dryRunWarnings : void 0
           };
-          const headSha = await this.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
+          const headSha = await this.service.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
           return {
             flow: "no-patches",
             previousGenerationSha,
             currentGenerationSha: headSha,
             baseBranchHead: options.baseBranchHead ?? null,
             _prepared: {
+              kind: "terminal",
               flow: "no-patches",
-              terminal: true,
-              preparedReport,
-              patchesToApply: [],
-              newPatchIds: /* @__PURE__ */ new Set(),
-              detectorWarnings,
-              revertedCount: revertedPatchIds.length,
-              genSha: headSha,
-              optionsSnapshot: options
+              preparedReport
             }
           };
         }
@@ -25794,7 +25800,7 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
           const uniqueFiles = [...new Set(newPatches.flatMap((p2) => p2.files))];
           const absorbedFiles = /* @__PURE__ */ new Set();
           for (const file of uniqueFiles) {
-            const diff = await this.git.exec(["diff", preCurrentGen, "HEAD", "--", file]).catch(() => null);
+            const diff = await this.service.git.exec(["diff", preCurrentGen, "HEAD", "--", file]).catch(() => null);
             if (diff !== null && !diff.trim()) {
               absorbedFiles.add(file);
             }
@@ -25807,7 +25813,7 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         }
         for (const id of revertedPatchIds) {
           try {
-            this.lockManager.removePatch(id);
+            this.service.lockManager.removePatch(id);
           } catch {
           }
         }
@@ -25816,18 +25822,18 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
           generatorVersions: options.generatorVersions ?? {},
           baseBranchHead: options.baseBranchHead
         } : void 0;
-        await this.committer.commitGeneration("Update SDK", commitOpts);
-        await this.cleanupStaleConflictMarkers();
-        const genRecord = await this.committer.createGenerationRecord(commitOpts);
-        this.lockManager.addGeneration(genRecord);
+        await this.service.committer.commitGeneration("Update SDK", commitOpts);
+        await this.service.cleanupStaleConflictMarkers();
+        const genRecord = await this.service.committer.createGenerationRecord(commitOpts);
+        this.service.lockManager.addGeneration(genRecord);
         return {
           flow: "no-patches",
           previousGenerationSha,
           currentGenerationSha: genRecord.commit_sha,
           baseBranchHead: options?.baseBranchHead ?? null,
           _prepared: {
+            kind: "active",
             flow: "no-patches",
-            terminal: false,
             patchesToApply: newPatches,
             newPatchIds: new Set(newPatches.map((p2) => p2.id)),
             detectorWarnings,
@@ -25837,41 +25843,42 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
           }
         };
       }
-      async _applyNoPatchesRegeneration(prep, options) {
+      async apply(prep, options) {
+        assertActive(prep);
         const newPatches = prep._prepared.patchesToApply;
         const detectorWarnings = prep._prepared.detectorWarnings;
         const genSha = prep._prepared.genSha;
         let results = [];
         if (newPatches.length > 0) {
-          results = await this.applicator.applyPatches(newPatches);
-          this._lastApplyResults = results;
-          this.recordDroppedContextLineWarnings(results);
-          this.revertConflictingFiles(results);
+          results = await this.service.applicator.applyPatches(newPatches);
+          this.service._lastApplyResults = results;
+          this.service.recordDroppedContextLineWarnings(results);
+          this.service.revertConflictingFiles(results);
           for (const result of results) {
             if (result.status === "conflict") {
               result.patch.status = "unresolved";
             }
           }
         }
-        const rebaseCounts = await this.rebasePatches(results, genSha);
+        const rebaseCounts = await this.service.rebasePatches(results, genSha);
         for (const patch of newPatches) {
           if (!rebaseCounts.absorbedPatchIds.has(patch.id)) {
-            this.lockManager.addPatch(patch);
+            this.service.lockManager.addPatch(patch);
           }
         }
-        this.lockManager.save();
-        this.warnings.push(...this.lockManager.warnings);
+        this.service.lockManager.save();
+        this.service.warnings.push(...this.service.lockManager.warnings);
         if (newPatches.length > 0) {
           if (!options?.stageOnly) {
             const appliedCount = results.filter((r2) => r2.status === "applied").length;
             const buckets = computeCommitBuckets(results, rebaseCounts.absorbedPatchIds, newPatches);
-            await this.committer.commitReplay(appliedCount, newPatches, void 0, { buckets });
+            await this.service.committer.commitReplay(appliedCount, newPatches, void 0, { buckets });
           } else {
-            await this.committer.stageAll();
+            await this.service.committer.stageAll();
           }
         }
-        const warnings = [...detectorWarnings, ...this.warnings];
-        return this.buildReport(
+        const warnings = [...detectorWarnings, ...this.service.warnings];
+        return this.service.buildReport(
           "no-patches",
           newPatches,
           results,
@@ -25882,13 +25889,18 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
           prep._prepared.revertedCount
         );
       }
-      async _prepareNormalRegeneration(options) {
-        const preLock = this.lockManager.read();
+    };
+    NormalRegenerationFlow = class {
+      constructor(service) {
+        this.service = service;
+      }
+      async prepare(options) {
+        const preLock = this.service.lockManager.read();
         const previousGenerationSha = preLock.current_generation ?? null;
         if (options?.dryRun) {
-          const existingPatches2 = this.lockManager.getPatches();
-          const { patches: newPatches2, revertedPatchIds: dryRunReverted } = await this.detector.detectNewPatches();
-          const warnings = [...this.detector.warnings, ...this.warnings];
+          const existingPatches2 = this.service.lockManager.getPatches();
+          const { patches: newPatches2, revertedPatchIds: dryRunReverted } = await this.service.detector.detectNewPatches();
+          const warnings = [...this.service.detector.warnings, ...this.service.warnings];
           const allPatches2 = [...existingPatches2, ...newPatches2];
           const preparedReport = {
             flow: "normal-regeneration",
@@ -25901,48 +25913,42 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
             wouldApply: allPatches2,
             warnings: warnings.length > 0 ? warnings : void 0
           };
-          const headSha = await this.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
+          const headSha = await this.service.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
           return {
             flow: "normal-regeneration",
             previousGenerationSha,
             currentGenerationSha: headSha,
             baseBranchHead: options.baseBranchHead ?? null,
             _prepared: {
+              kind: "terminal",
               flow: "normal-regeneration",
-              terminal: true,
-              preparedReport,
-              patchesToApply: [],
-              newPatchIds: /* @__PURE__ */ new Set(),
-              detectorWarnings: [...this.detector.warnings],
-              revertedCount: dryRunReverted.length,
-              genSha: headSha,
-              optionsSnapshot: options
+              preparedReport
             }
           };
         }
-        let existingPatches = this.lockManager.getPatches();
+        let existingPatches = this.service.lockManager.getPatches();
         const preRebasePatchIds = new Set(existingPatches.map((p2) => p2.id));
-        const preRebaseCounts = await this.preGenerationRebase(existingPatches);
-        const postRebasePatchIds = new Set(this.lockManager.getPatches().map((p2) => p2.id));
+        const preRebaseCounts = await this.service.preGenerationRebase(existingPatches);
+        const postRebasePatchIds = new Set(this.service.lockManager.getPatches().map((p2) => p2.id));
         const removedByPreRebase = existingPatches.filter(
           (p2) => preRebasePatchIds.has(p2.id) && !postRebasePatchIds.has(p2.id)
         );
-        existingPatches = this.lockManager.getPatches();
+        existingPatches = this.service.lockManager.getPatches();
         const seenHashes = /* @__PURE__ */ new Map();
         for (const p2 of existingPatches) {
           const priorPatchId = seenHashes.get(p2.content_hash);
           if (priorPatchId !== void 0) {
-            this.lockManager.removePatch(p2.id);
-            this.warnings.push(
+            this.service.lockManager.removePatch(p2.id);
+            this.service.warnings.push(
               `Consolidated patch ${p2.id} (commit ${(p2.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(p2.content_hash, p2.id);
           }
         }
-        existingPatches = this.lockManager.getPatches();
-        let { patches: newPatches, revertedPatchIds } = await this.detector.detectNewPatches();
-        const detectorWarnings = [...this.detector.warnings];
+        existingPatches = this.service.lockManager.getPatches();
+        let { patches: newPatches, revertedPatchIds } = await this.service.detector.detectNewPatches();
+        const detectorWarnings = [...this.service.detector.warnings];
         if (removedByPreRebase.length > 0) {
           const removedOriginalCommits = new Set(removedByPreRebase.map((p2) => p2.original_commit));
           const removedOriginalMessages = new Set(removedByPreRebase.map((p2) => p2.original_message));
@@ -25957,7 +25963,7 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         }
         for (const id of revertedPatchIds) {
           try {
-            this.lockManager.removePatch(id);
+            this.service.lockManager.removePatch(id);
           } catch {
           }
         }
@@ -25969,18 +25975,18 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
           generatorVersions: options.generatorVersions ?? {},
           baseBranchHead: options.baseBranchHead
         } : void 0;
-        await this.committer.commitGeneration("Update SDK", commitOpts);
-        await this.cleanupStaleConflictMarkers();
-        const genRecord = await this.committer.createGenerationRecord(commitOpts);
-        this.lockManager.addGeneration(genRecord);
+        await this.service.committer.commitGeneration("Update SDK", commitOpts);
+        await this.service.cleanupStaleConflictMarkers();
+        const genRecord = await this.service.committer.createGenerationRecord(commitOpts);
+        this.service.lockManager.addGeneration(genRecord);
         return {
           flow: "normal-regeneration",
           previousGenerationSha,
           currentGenerationSha: genRecord.commit_sha,
           baseBranchHead: options?.baseBranchHead ?? null,
           _prepared: {
+            kind: "active",
             flow: "normal-regeneration",
-            terminal: false,
             patchesToApply: allPatches,
             newPatchIds: new Set(newPatches.map((p2) => p2.id)),
             preRebaseCounts,
@@ -25991,46 +25997,47 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
           }
         };
       }
-      async _applyNormalRegeneration(prep, options) {
+      async apply(prep, options) {
+        assertActive(prep);
         const allPatches = prep._prepared.patchesToApply;
         const newPatchIds = prep._prepared.newPatchIds;
         const detectorWarnings = prep._prepared.detectorWarnings;
         const genSha = prep._prepared.genSha;
-        const results = await this.applicator.applyPatches(allPatches);
-        this._lastApplyResults = results;
-        this.recordDroppedContextLineWarnings(results);
-        this.revertConflictingFiles(results);
+        const results = await this.service.applicator.applyPatches(allPatches);
+        this.service._lastApplyResults = results;
+        this.service.recordDroppedContextLineWarnings(results);
+        this.service.revertConflictingFiles(results);
         for (const result of results) {
           if (result.status === "conflict") {
             result.patch.status = "unresolved";
           }
         }
-        const rebaseCounts = await this.rebasePatches(results, genSha);
+        const rebaseCounts = await this.service.rebasePatches(results, genSha);
         const newPatches = allPatches.filter((p2) => newPatchIds.has(p2.id));
         for (const patch of newPatches) {
           if (!rebaseCounts.absorbedPatchIds.has(patch.id)) {
-            this.lockManager.addPatch(patch);
+            this.service.lockManager.addPatch(patch);
           }
         }
         for (const result of results) {
           if (result.status === "conflict") {
             try {
-              this.lockManager.markPatchUnresolved(result.patch.id);
+              this.service.lockManager.markPatchUnresolved(result.patch.id);
             } catch {
             }
           }
         }
-        this.lockManager.save();
-        this.warnings.push(...this.lockManager.warnings);
+        this.service.lockManager.save();
+        this.service.warnings.push(...this.service.lockManager.warnings);
         if (options?.stageOnly) {
-          await this.committer.stageAll();
+          await this.service.committer.stageAll();
         } else {
           const appliedCount = results.filter((r2) => r2.status === "applied").length;
           const buckets = computeCommitBuckets(results, rebaseCounts.absorbedPatchIds, allPatches);
-          await this.committer.commitReplay(appliedCount, allPatches, void 0, { buckets });
+          await this.service.committer.commitReplay(appliedCount, allPatches, void 0, { buckets });
         }
-        const warnings = [...detectorWarnings, ...this.warnings];
-        return this.buildReport(
+        const warnings = [...detectorWarnings, ...this.service.warnings];
+        return this.service.buildReport(
           "normal-regeneration",
           allPatches,
           results,
@@ -26041,10 +26048,204 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
           prep._prepared.revertedCount
         );
       }
+    };
+    ReplayService = class {
+      /** @internal Used by Flow implementations in `src/flows/`. */
+      git;
+      /** @internal Used by Flow implementations in `src/flows/`. */
+      detector;
+      /** @internal Used by Flow implementations in `src/flows/`. */
+      applicator;
+      /** @internal Used by Flow implementations in `src/flows/`. */
+      committer;
+      /** @internal Used by Flow implementations in `src/flows/`. */
+      lockManager;
+      /** @internal Used by Flow implementations in `src/flows/`. */
+      fileOwnership;
+      /** @internal Used by Flow implementations in `src/flows/`. */
+      outputDir;
+      /** @internal Test-only. Captures the last ReplayResult[] returned from applicator.applyPatches(). */
+      _lastApplyResults = [];
+      /**
+       * Service-level warnings accumulated during a single runReplay() call.
+       * Merged with `detector.warnings` into `ReplayReport.warnings` by each flow handler.
+       * Populated by `FileOwnership.resolveCanonical` when a patch's base generation tree
+       * is unreachable (shallow clone / aggressive `git gc --prune`) and we fall back to a
+       * conservative heuristic. Cleared at the top of `runReplay()`.
+       *
+       * @internal Used by Flow implementations in `src/flows/`.
+       */
+      warnings = [];
+      /**
+       * @internal Test-only accessor.
+       * Returns the ReplayApplicator instance used for the last run. Tests use this
+       * to inspect the inter-patch accumulator after runReplay() completes (invariant I2).
+       */
+      get applicatorRef() {
+        return this.applicator;
+      }
+      /**
+       * @internal Test-only accessor.
+       * Returns the ReplayResult[] from the most recent applyPatches() call. Tests use
+       * this to filter applied-vs-conflicted-vs-absorbed patches for invariant
+       * assertions. Returns an empty array if no patches have been applied yet.
+       */
+      getLastResults() {
+        return this._lastApplyResults;
+      }
+      constructor(outputDir, _config) {
+        const git = new GitClient(outputDir);
+        this.git = git;
+        this.outputDir = outputDir;
+        this.lockManager = new LockfileManager(outputDir);
+        this.detector = new ReplayDetector(git, this.lockManager, outputDir);
+        this.applicator = new ReplayApplicator(git, this.lockManager, outputDir);
+        this.committer = new ReplayCommitter(git, outputDir);
+        this.fileOwnership = new FileOwnership(git);
+      }
+      /**
+       * Phase 1 of the two-phase replay flow. Runs preGenerationRebase (when applicable),
+       * detects new patches, and creates the `[fern-generated]` commit. Leaves HEAD at
+       * the generation commit (or unchanged for dry-run).
+       *
+       * Does NOT apply patches — the returned handle must be passed to
+       * `applyPreparedReplay()` to complete the run. No disk writes to the lockfile
+       * happen here; lockfile persistence is deferred to phase 2.
+       *
+       * Callers may land additional commits on HEAD between `prepareReplay` and
+       * `applyPreparedReplay` (e.g., `[fern-autoversion]`).
+       */
+      async prepareReplay(options) {
+        this.warnings = [];
+        this.detector.warnings.length = 0;
+        return this.selectFlow(options).prepare(options);
+      }
+      /**
+       * Phase 2 of the two-phase replay flow. Applies patches, rebases them against
+       * the generation, saves the lockfile, and commits `[fern-replay]` (or stages
+       * under `stageOnly`). Operates on HEAD at call time — mid-phase commits are
+       * respected.
+       *
+       * For terminal handles (dry-run, first-gen has no patch work, skip-app does
+       * its own post-commit logic), this returns the precomputed report.
+       */
+      async applyPreparedReplay(prep, options) {
+        if (prep._prepared.kind === "terminal") {
+          return prep._prepared.preparedReport;
+        }
+        return this.flowForKind(prep._prepared.flow).apply(prep, options);
+      }
+      /**
+       * Construct the flow for the current run. `selectFlow` is called from
+       * `prepareReplay` and decides based on options + lockfile state.
+       */
+      selectFlow(options) {
+        if (options?.skipApplication) return new SkipApplicationFlow(this);
+        return this.flowForKind(this.determineFlow());
+      }
+      /**
+       * Construct a flow given its kind. Used by `applyPreparedReplay` to
+       * route to the same kind that was selected in phase 1.
+       */
+      flowForKind(kind) {
+        switch (kind) {
+          case "first-generation":
+            return new FirstGenerationFlow(this);
+          case "no-patches":
+            return new NoPatchesFlow(this);
+          case "normal-regeneration":
+            return new NormalRegenerationFlow(this);
+          case "skip-application":
+            return new SkipApplicationFlow(this);
+        }
+      }
+      /**
+       * Backwards-compatible atomic entry point. Composes `prepareReplay` + `applyPreparedReplay`.
+       * Behavior is byte-identical to the pre-split implementation for all existing callers.
+       */
+      async runReplay(options) {
+        const prep = await this.prepareReplay(options);
+        return this.applyPreparedReplay(prep, options);
+      }
+      /**
+       * Sync the lockfile after a divergent PR was squash-merged.
+       * Call this BEFORE runReplay() when the CLI detects a merged divergent PR.
+       *
+       * After updating the generation record, re-detects customer patches via
+       * tree diff between the generation tag (pure generation tree) and HEAD
+       * (which includes customer customizations after squash merge). This ensures
+       * patches survive the squash merge → regenerate cycle even when the lockfile
+       * was restored from the base branch during conflict PR creation.
+       */
+      async syncFromDivergentMerge(generationCommitSha, options) {
+        const treeHash = await this.git.getTreeHash(generationCommitSha);
+        const timestamp = (await this.git.exec(["log", "-1", "--format=%aI", generationCommitSha])).trim();
+        const record2 = {
+          commit_sha: generationCommitSha,
+          tree_hash: treeHash,
+          timestamp,
+          cli_version: options?.cliVersion ?? "unknown",
+          generator_versions: options?.generatorVersions ?? {},
+          base_branch_head: options?.baseBranchHead
+        };
+        let resolvedPatches;
+        if (!this.lockManager.exists()) {
+          this.lockManager.initializeInMemory(record2);
+        } else {
+          this.lockManager.read();
+          const unresolvedPatches = [
+            ...this.lockManager.getUnresolvedPatches(),
+            ...this.lockManager.getResolvingPatches()
+          ];
+          resolvedPatches = this.lockManager.getPatches().filter((p2) => p2.status == null);
+          this.lockManager.addGeneration(record2);
+          this.lockManager.clearPatches();
+          for (const patch of unresolvedPatches) {
+            this.lockManager.addPatch(patch);
+          }
+        }
+        try {
+          const { patches: redetectedPatches } = await this.detector.detectNewPatches();
+          if (redetectedPatches.length > 0) {
+            const redetectedFiles = new Set(redetectedPatches.flatMap((p2) => p2.files));
+            const currentPatches = this.lockManager.getPatches();
+            for (const patch of currentPatches) {
+              if (patch.status != null && patch.files.some((f) => redetectedFiles.has(f))) {
+                this.lockManager.removePatch(patch.id);
+              }
+            }
+            for (const patch of redetectedPatches) {
+              this.lockManager.addPatch(patch);
+            }
+          }
+        } catch (error) {
+          for (const patch of resolvedPatches ?? []) {
+            this.lockManager.addPatch(patch);
+          }
+          this.detector.warnings.push(
+            `Patch re-detection failed after divergent merge sync. ${(resolvedPatches ?? []).length} previously resolved patch(es) preserved. Error: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+        this.lockManager.save();
+        this.detector.warnings.push(...this.lockManager.warnings);
+      }
+      determineFlow() {
+        try {
+          const lock = this.lockManager.read();
+          return lock.patches.length === 0 ? "no-patches" : "normal-regeneration";
+        } catch (error) {
+          if (error instanceof LockfileNotFoundError) {
+            return "first-generation";
+          }
+          throw error;
+        }
+      }
       /**
        * Rebase cleanly applied patches so they are relative to the current generation.
        * This prevents recurring conflicts on subsequent regenerations.
        * Returns the number of patches rebased.
+       *
+       * @internal Used by Flow implementations in `src/flows/`.
        */
       async rebasePatches(results, currentGenSha) {
         let absorbed = 0;
@@ -26054,6 +26255,7 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         const seenContentHashes = /* @__PURE__ */ new Map();
         const absorbedPatchIds = /* @__PURE__ */ new Set();
         const fernignorePatterns = this.readFernignorePatterns();
+        const warnedGens = /* @__PURE__ */ new Set();
         for (const result of results) {
           if (result.resolvedFiles && Object.keys(result.resolvedFiles).length > 0) {
             const patch = result.patch;
@@ -26098,18 +26300,17 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
               }
             }
             const isUserOwnedPerFile = await Promise.all(
-              patch.files.map(async (file) => {
-                if (file === ".fernignore") return true;
-                if (fernignorePatterns.some((p2) => file === p2 || minimatch(file, p2))) {
-                  return true;
-                }
-                if (patch.user_owned) return true;
-                if (this.fileIsCreationInPatchContent(patch.patch_content, originalByResolved[file] ?? file)) {
-                  return true;
-                }
-                const content = await this.git.showFile(currentGenSha, file);
-                return content === null;
-              })
+              patch.files.map(
+                (file) => this.fileOwnership.resolveCanonical({
+                  file,
+                  originalFileName: originalByResolved[file],
+                  patch,
+                  currentGenSha,
+                  fernignorePatterns,
+                  warnedGens,
+                  warnings: this.warnings
+                })
+              )
             );
             const hasProtectedFiles = patch.files.some(
               (file) => file === ".fernignore" || fernignorePatterns.some((p2) => file === p2 || minimatch(file, p2))
@@ -26236,7 +26437,7 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         for (const file of files) {
           if (isBinaryFile(file)) continue;
           try {
-            const content = await (0, import_promises5.readFile)((0, import_path10.join)(this.outputDir, file), "utf-8");
+            const content = await (0, import_promises7.readFile)((0, import_path13.join)(this.outputDir, file), "utf-8");
             snapshot[file] = content;
           } catch {
           }
@@ -26244,10 +26445,16 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         return snapshot;
       }
       /**
-       * FER-10203: returns true when a `[fern-autoversion]` commit between
-       * `fromSha` and `toSha` touched any of the patch's `files`. Re-classifies
-       * each grep match via `isGenerationCommit` so a customer commit that
-       * merely quotes the marker in its body doesn't false-positive.
+       * Detects autoversion contamination — returns true when a
+       * `[fern-autoversion]` commit between `fromSha` and `toSha` touched any
+       * of the patch's `files`. Re-classifies each grep match via
+       * `isGenerationCommit` so a customer commit that merely quotes the
+       * marker in its body doesn't false-positive.
+       *
+       * Used by preGenerationRebase to skip the customer-content rebuild for
+       * patches whose files were last touched by an autoversion step — a
+       * naive `git diff currentGen HEAD` there would capture the
+       * placeholder→semver swap as customer customization.
        */
       async hasAutoversionContamination(fromSha, toSha, files) {
         if (files.length === 0) return false;
@@ -26276,10 +26483,15 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         return false;
       }
       /**
-       * FER-10203: rebuild patch_content from `theirs_snapshot` (captured at
-       * detection time, predates pipeline content) rather than a HEAD-relative
-       * diff. Returns `null` when snapshot is missing or doesn't cover every
-       * file in `patch.files` — caller leaves the patch unchanged.
+       * Rebuild patch_content from `theirs_snapshot` (captured at detection
+       * time, predates pipeline content) rather than a HEAD-relative diff.
+       * Returns `null` when snapshot is missing or doesn't cover every file
+       * in `patch.files` — caller leaves the patch unchanged.
+       *
+       * Used as the autoversion-contamination escape hatch: when the
+       * HEAD-relative diff would capture pipeline content (autoversion's
+       * placeholder swap) as customer customization, the snapshot path
+       * preserves the customer's actual intent.
        */
       async computeSnapshotBasedPatchDiff(patch, currentGen) {
         if (!patch.theirs_snapshot) return null;
@@ -26327,7 +26539,7 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
        * **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
+       * into one patch's snapshot — breaking 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
@@ -26389,72 +26601,6 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
           );
         }
       }
-      /**
-       * Determine whether `file` is user-owned (never produced by the generator).
-       *
-       * Resolution order (first match wins):
-       *  1. `patch.user_owned === true` — authoritative, persisted across cycles.
-       *  2. `.fernignore` itself, or file matches a .fernignore pattern.
-       *  3. Legacy-safe signal: `patch_content` shows this file as a `--- /dev/null`
-       *     creation. Works for patches that predate the `user_owned` field or
-       *     whose flag was lost. Immune to rename tricks — relies on raw patch text.
-       *  4. Tree-based check against `patch.base_generation` when it is reachable
-       *     AND distinct from `currentGenSha`. If the base tree is unreachable
-       *     (shallow clone / aggressive `git gc --prune`), emit a one-time
-       *     customer-actionable warning (deduplicated via warnedGens) and
-       *     conservatively treat as user-owned — strictly safer than silent
-       *     absorption (FER-9809).
-       *  5. Final fallback — check `currentGenSha` when there is no usable base
-       *     (legacy one-gen lockfile). Preserves pre-fix behavior for that edge.
-       *
-       * `originalFileName` is the pre-rename path when the generator moved the
-       * file between the patch's base and the current generation. Tree lookups
-       * at ancestor generations use the original path — that's where the
-       * generator produced the content.
-       */
-      async isFileUserOwned(file, patch, currentGenSha, fernignorePatterns, warnedGens, originalFileName) {
-        if (patch.user_owned) return true;
-        if (file === ".fernignore") return true;
-        if (fernignorePatterns.some((p2) => file === p2 || minimatch(file, p2))) return true;
-        if (this.fileIsCreationInPatchContent(patch.patch_content, originalFileName ?? file)) {
-          return true;
-        }
-        const base = patch.base_generation;
-        if (base && base !== currentGenSha) {
-          const reachable = await this.git.commitExists(base) || await this.git.treeExists(base);
-          if (!reachable) {
-            if (!warnedGens.has(base)) {
-              warnedGens.add(base);
-              this.warnings.push(
-                `Base generation ${base.slice(0, 7)} is unreachable (shallow clone or pruned history). Treating affected files as user-owned to avoid silent data loss. Run \`git fetch --unshallow\` or avoid \`git gc --prune\` to restore full history.`
-              );
-            }
-            return true;
-          }
-          return await this.git.showFile(base, originalFileName ?? file) === null;
-        }
-        return await this.git.showFile(currentGenSha, originalFileName ?? file) === null;
-      }
-      /**
-       * Returns true if `file`'s diff section in `patchContent` starts with
-       * `--- /dev/null`, meaning this file was introduced by the patch (user
-       * creation). Used as a legacy-safe fallback when `patch.user_owned` is
-       * absent or cleared.
-       */
-      fileIsCreationInPatchContent(patchContent, file) {
-        const lines = patchContent.split("\n");
-        let inFileSection = false;
-        for (const line of lines) {
-          if (line.startsWith("diff --git ")) {
-            inFileSection = line.includes(` b/${file}`) || line.endsWith(` b/${file}`);
-            continue;
-          }
-          if (inFileSection && line.startsWith("--- ")) {
-            return line === "--- /dev/null";
-          }
-        }
-        return false;
-      }
       /**
        * For conflict patches with mixed results (some files merged, some conflicted),
        * check if the cleanly merged files were absorbed by the generator (empty diff).
@@ -26473,7 +26619,15 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         const warnedGens = /* @__PURE__ */ new Set();
         const generatorCleanFiles = [];
         for (const file of cleanFiles) {
-          if (await this.isFileUserOwned(file, patch, currentGenSha, fernignorePatterns, warnedGens)) {
+          const userOwned = await this.fileOwnership.resolveCanonical({
+            file,
+            patch,
+            currentGenSha,
+            fernignorePatterns,
+            warnedGens,
+            warnings: this.warnings
+          });
+          if (userOwned) {
             continue;
           }
           generatorCleanFiles.push(file);
@@ -26502,6 +26656,7 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
        * Pre-generation rebase: update patches using the customer's current state.
        * Called BEFORE commitGeneration() while HEAD has customer code.
        */
+      /** @internal Used by Flow implementations in `src/flows/`. */
       async preGenerationRebase(patches) {
         const lock = this.lockManager.read();
         const currentGen = lock.current_generation;
@@ -26540,7 +26695,15 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
           if (patch.user_owned) return true;
           if (patch.files.length === 0) return false;
           for (const file of patch.files) {
-            if (!await this.isFileUserOwned(file, patch, currentGen, fernignorePatterns, warnedGens)) {
+            const userOwned = await this.fileOwnership.resolveCanonical({
+              file,
+              patch,
+              currentGenSha: currentGen,
+              fernignorePatterns,
+              warnedGens,
+              warnings: this.warnings
+            });
+            if (!userOwned) {
               return false;
             }
           }
@@ -26732,6 +26895,7 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
        * relied on them. This is the "surface or preserve, never silently drop"
        * contract for legitimate-deletion cases.
        */
+      /** @internal Used by Flow implementations in `src/flows/`. */
       recordDroppedContextLineWarnings(results) {
         const PREVIEW_COUNT = 5;
         for (const result of results) {
@@ -26754,12 +26918,13 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
        * After applyPatches(), strip conflict markers from conflicting files
        * so only clean content is committed. Keeps the Generated (OURS) side.
        */
+      /** @internal Used by Flow implementations in `src/flows/`. */
       revertConflictingFiles(results) {
         for (const result of results) {
           if (result.status !== "conflict" || !result.fileResults) continue;
           for (const fileResult of result.fileResults) {
             if (fileResult.status !== "conflict") continue;
-            const filePath = (0, import_path10.join)(this.outputDir, fileResult.file);
+            const filePath = (0, import_path13.join)(this.outputDir, fileResult.file);
             try {
               const content = (0, import_fs7.readFileSync)(filePath, "utf-8");
               const stripped = stripConflictMarkers(content);
@@ -26775,6 +26940,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
        * Restores files to their clean generated state from HEAD.
        * Skips .fernignore-protected files to prevent overwriting user content.
        */
+      /** @internal Used by Flow implementations in `src/flows/`. */
       async cleanupStaleConflictMarkers() {
         const markerFiles = await this.git.exec(["grep", "-l", "<<<<<<< Generated", "--", "."]).catch(() => "");
         const files = markerFiles.trim().split("\n").filter(Boolean);
@@ -26789,10 +26955,11 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         }
       }
       readFernignorePatterns() {
-        const fernignorePath = (0, import_path10.join)(this.outputDir, ".fernignore");
+        const fernignorePath = (0, import_path13.join)(this.outputDir, ".fernignore");
         if (!(0, import_fs7.existsSync)(fernignorePath)) return [];
         return (0, import_fs7.readFileSync)(fernignorePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
       }
+      /** @internal Used by Flow implementations in `src/flows/`. */
       buildReport(flow, patches, results, options, warnings, rebaseCounts, preRebaseCounts, patchesReverted) {
         const conflictResults = results.filter((r2) => r2.status === "conflict");
         const conflictDetails = conflictResults.map((r2) => {
@@ -26847,10 +27014,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_fs8.existsSync)((0, import_path12.join)(this.outputDir, ".fernignore"));
+        return (0, import_fs8.existsSync)((0, import_path15.join)(this.outputDir, ".fernignore"));
       }
       readFernignorePatterns() {
-        const fernignorePath = (0, import_path12.join)(this.outputDir, ".fernignore");
+        const fernignorePath = (0, import_path15.join)(this.outputDir, ".fernignore");
         if (!(0, import_fs8.existsSync)(fernignorePath)) {
           return [];
         }
@@ -26959,7 +27126,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_path12.join)(this.outputDir, filePath);
+        const fullPath = (0, import_path15.join)(this.outputDir, filePath);
         if (!(0, import_fs8.existsSync)(fullPath)) {
           return null;
         }
@@ -27024,7 +27191,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_path12.join)(this.outputDir, ".fern", "replay.yml");
+        const replayYmlPath = (0, import_path15.join)(this.outputDir, ".fern", "replay.yml");
         let config = {};
         if ((0, import_fs8.existsSync)(replayYmlPath)) {
           const content = (0, import_fs8.readFileSync)(replayYmlPath, "utf-8");
@@ -27033,7 +27200,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         const existing = config.exclude ?? [];
         const merged = [.../* @__PURE__ */ new Set([...existing, ...patterns])];
         config.exclude = merged;
-        const dir = (0, import_path12.dirname)(replayYmlPath);
+        const dir = (0, import_path15.dirname)(replayYmlPath);
         if (!(0, import_fs8.existsSync)(dir)) {
           (0, import_fs8.mkdirSync)(dir, { recursive: true });
         }
@@ -29639,8 +29806,8 @@ function resolve(...paths) {
 
 // src/cli.ts
 var import_fs16 = __toESM(require("fs"));
-var import_promises16 = require("fs/promises");
-var import_path22 = __toESM(require("path"));
+var import_promises18 = require("fs/promises");
+var import_path25 = __toESM(require("path"));
 
 // ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/yerror.js
 var YError = class _YError extends Error {
@@ -31607,15 +31774,18 @@ function parseRepository(githubRepository) {
     githubRepository = githubRepository.slice(0, -4);
   }
   const parts = githubRepository.split("/");
-  if (parts.length === 2 && parts[0] != null && parts[1] != null) {
+  if (parts.length === 2 && isNonEmptyPart(parts[0]) && isNonEmptyPart(parts[1])) {
     [owner, repo] = parts;
-  } else if (parts.length === 3 && parts[0] != null && parts[1] != null && parts[2] != null) {
+  } else if (parts.length === 3 && isNonEmptyPart(parts[0]) && isNonEmptyPart(parts[1]) && isNonEmptyPart(parts[2])) {
     [remote, owner, repo] = parts;
   } else {
     throw new Error(`Failed to parse GitHub repository ${githubRepository}`);
   }
   return newRepositoryReference({ remote, owner, repo });
 }
+function isNonEmptyPart(part) {
+  return part != null && part.length > 0;
+}
 function newRepositoryReference({ remote, owner, repo }) {
   const repoUrl = getRepoUrl({ remote, owner, repo });
   const cloneUrl = getCloneUrl({ remote, owner, repo });
@@ -39354,42 +39524,42 @@ function replayForget(params) {
 // src/replay/replay-init.ts
 init_dist3();
 var import_fs11 = require("fs");
-var import_path16 = require("path");
+var import_path19 = require("path");
 var import_tmp_promise2 = __toESM(require_tmp_promise());
 
 // src/replay/fernignore.ts
-var import_promises8 = require("fs/promises");
-var import_path15 = require("path");
+var import_promises10 = require("fs/promises");
+var import_path18 = require("path");
 var REPLAY_FERNIGNORE_ENTRIES2 = [".fern/replay.lock", ".fern/replay.yml", ".gitattributes"];
 var GITATTRIBUTES_ENTRIES2 = [".fern/replay.lock linguist-generated=true"];
 async function ensureReplayFernignoreEntries(outputDir) {
-  const fernignorePath = (0, import_path15.join)(outputDir, ".fernignore");
+  const fernignorePath = (0, import_path18.join)(outputDir, ".fernignore");
   let content = "";
   try {
-    content = await (0, import_promises8.readFile)(fernignorePath, "utf-8");
+    content = await (0, import_promises10.readFile)(fernignorePath, "utf-8");
   } catch {
   }
   const lines = content.split("\n");
   const toAdd = REPLAY_FERNIGNORE_ENTRIES2.filter((entry) => !lines.some((line) => line.trim() === entry));
   if (toAdd.length > 0) {
     const suffix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
-    await (0, import_promises8.writeFile)(fernignorePath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
+    await (0, import_promises10.writeFile)(fernignorePath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
     return true;
   }
   return false;
 }
 async function ensureGitattributesEntries2(outputDir) {
-  const gitattributesPath = (0, import_path15.join)(outputDir, ".gitattributes");
+  const gitattributesPath = (0, import_path18.join)(outputDir, ".gitattributes");
   let content = "";
   try {
-    content = await (0, import_promises8.readFile)(gitattributesPath, "utf-8");
+    content = await (0, import_promises10.readFile)(gitattributesPath, "utf-8");
   } catch {
   }
   const lines = content.split("\n");
   const toAdd = GITATTRIBUTES_ENTRIES2.filter((entry) => !lines.some((line) => line.trim() === entry));
   if (toAdd.length > 0) {
     const suffix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
-    await (0, import_promises8.writeFile)(gitattributesPath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
+    await (0, import_promises10.writeFile)(gitattributesPath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
   }
 }
 
@@ -39416,7 +39586,7 @@ async function replayInit(params) {
   if (dryRun) {
     return { bootstrap: bootstrapResult, fernignoreEntries: [], gitattributesEntries: [] };
   }
-  const lockfilePath = (0, import_path16.join)(repoPath, ".fern", "replay.lock");
+  const lockfilePath = (0, import_path19.join)(repoPath, ".fern", "replay.lock");
   const lockfileContent = (0, import_fs11.existsSync)(lockfilePath) ? (0, import_fs11.readFileSync)(lockfilePath, "utf-8") : void 0;
   return {
     bootstrap: bootstrapResult,
@@ -39539,7 +39709,7 @@ init_dist3();
 init_dist3();
 var import_child_process4 = require("child_process");
 var import_fs12 = require("fs");
-var import_path17 = require("path");
+var import_path20 = require("path");
 async function replayPrepare(params, state) {
   const {
     outputDir,
@@ -39550,7 +39720,7 @@ async function replayPrepare(params, state) {
     skipApplication,
     logger
   } = params;
-  const lockfilePath = (0, import_path17.join)(outputDir, ".fern", "replay.lock");
+  const lockfilePath = (0, import_path20.join)(outputDir, ".fern", "replay.lock");
   let autoBootstrapped = false;
   let bootstrapAttempted = false;
   if (!(0, import_fs12.existsSync)(lockfilePath)) {
@@ -39804,29 +39974,29 @@ function replayStatus(params) {
 }
 
 // src/configuration/loadGitHubConfig.ts
-var import_promises9 = require("fs/promises");
+var import_promises11 = require("fs/promises");
 async function loadGitHubConfig({
   absolutePathToConfig
 }) {
-  const rawContents = await (0, import_promises9.readFile)(absolutePathToConfig, "utf8");
+  const rawContents = await (0, import_promises11.readFile)(absolutePathToConfig, "utf8");
   return JSON.parse(rawContents);
 }
 
 // src/configuration/loadReadmeConfig.ts
-var import_promises10 = require("fs/promises");
+var import_promises12 = require("fs/promises");
 async function loadReadmeConfig({
   absolutePathToConfig
 }) {
-  const rawContents = await (0, import_promises10.readFile)(absolutePathToConfig, "utf8");
+  const rawContents = await (0, import_promises12.readFile)(absolutePathToConfig, "utf8");
   return JSON.parse(rawContents);
 }
 
 // src/configuration/loadReferenceConfig.ts
-var import_promises11 = require("fs/promises");
+var import_promises13 = require("fs/promises");
 async function loadReferenceConfig({
   absolutePathToConfig
 }) {
-  const rawContents = await (0, import_promises11.readFile)(absolutePathToConfig, "utf8");
+  const rawContents = await (0, import_promises13.readFile)(absolutePathToConfig, "utf8");
   return JSON.parse(rawContents);
 }
 
@@ -39853,8 +40023,8 @@ var FERN_BOT_LOGIN2 = "fern-api[bot]";
 // src/pipeline/steps/AutoVersionStep.ts
 var import_child_process5 = require("child_process");
 var import_fs14 = require("fs");
-var import_promises13 = require("fs/promises");
-var import_path19 = require("path");
+var import_promises15 = require("fs/promises");
+var import_path22 = require("path");
 
 // ../commons/logging-execa/lib/loggingExeca.js
 var import_execa = __toESM(require_execa(), 1);
@@ -39911,10 +40081,136 @@ async function loggingExeca(logger, executable, args = [], { doNotPipeOutput = f
   return result;
 }
 
+// ../cli/task-context/lib/CliError.js
+var CliError = class _CliError extends Error {
+  code;
+  docsLink;
+  constructor({ message, code, docsLink }) {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = this.constructor.name;
+    this.code = code;
+    this.docsLink = docsLink;
+  }
+  static authRequired(message) {
+    return new _CliError({
+      message: message ?? "Authentication required. Please run 'fern login' or set the FERN_TOKEN environment variable.",
+      code: _CliError.Code.AuthError
+    });
+  }
+  static unauthorized(message) {
+    return new _CliError({
+      message: message ?? "Unauthorized. Please run 'fern auth login' or set the FERN_TOKEN environment variable.",
+      code: _CliError.Code.AuthError
+    });
+  }
+  static notFound(message) {
+    return new _CliError({ message, code: _CliError.Code.ConfigError });
+  }
+  static badRequest(message) {
+    return new _CliError({ message, code: _CliError.Code.NetworkError });
+  }
+  static validationError(message) {
+    return new _CliError({ message, code: _CliError.Code.ValidationError });
+  }
+  static internalError(message) {
+    return new _CliError({ message, code: _CliError.Code.InternalError });
+  }
+};
+(function(CliError2) {
+  CliError2.Code = {
+    InternalError: "INTERNAL_ERROR",
+    ResolutionError: "RESOLUTION_ERROR",
+    IrConversionError: "IR_CONVERSION_ERROR",
+    ContainerError: "CONTAINER_ERROR",
+    VersionError: "VERSION_ERROR",
+    ParseError: "PARSE_ERROR",
+    EnvironmentError: "ENVIRONMENT_ERROR",
+    ReferenceError: "REFERENCE_ERROR",
+    ValidationError: "VALIDATION_ERROR",
+    NetworkError: "NETWORK_ERROR",
+    AuthError: "AUTH_ERROR",
+    ConfigError: "CONFIG_ERROR",
+    UserError: "USER_ERROR"
+  };
+})(CliError || (CliError = {}));
+var SENTRY_REPORTABLE = {
+  [CliError.Code.InternalError]: true,
+  [CliError.Code.ResolutionError]: true,
+  [CliError.Code.IrConversionError]: true,
+  [CliError.Code.ContainerError]: false,
+  [CliError.Code.VersionError]: false,
+  [CliError.Code.ParseError]: false,
+  [CliError.Code.EnvironmentError]: false,
+  [CliError.Code.ReferenceError]: false,
+  [CliError.Code.ValidationError]: false,
+  [CliError.Code.NetworkError]: false,
+  [CliError.Code.AuthError]: false,
+  [CliError.Code.ConfigError]: false,
+  [CliError.Code.UserError]: false
+};
+
+// ../cli/logger/lib/LogLevel.js
+var LogLevel2 = {
+  Trace: "trace",
+  Debug: "debug",
+  Info: "info",
+  Warn: "warn",
+  Error: "error"
+};
+var LOG_LEVELS = Object.values(LogLevel2);
+
+// ../cli/logger/lib/createLogger.js
+var LoggerImpl = class {
+  log;
+  enabled;
+  constructor(log, enabled = true) {
+    this.log = log;
+    this.enabled = enabled;
+  }
+  disable() {
+    this.enabled = false;
+  }
+  enable() {
+    this.enabled = true;
+  }
+  debug(...args) {
+    if (this.enabled) {
+      this.log(LogLevel2.Debug, ...args);
+    }
+  }
+  info(...args) {
+    if (this.enabled) {
+      this.log(LogLevel2.Info, ...args);
+    }
+  }
+  warn(...args) {
+    if (this.enabled) {
+      this.log(LogLevel2.Warn, ...args);
+    }
+  }
+  error(...args) {
+    if (this.enabled) {
+      this.log(LogLevel2.Error, ...args);
+    }
+  }
+  trace(...args) {
+    if (this.enabled) {
+      this.log(LogLevel2.Trace, ...args);
+    }
+  }
+};
+function createLogger4(log) {
+  return new LoggerImpl(log);
+}
+
 // src/autoversion/AutoVersioningService.ts
 var import_fs13 = require("fs");
-var import_promises12 = require("fs/promises");
-var import_path18 = require("path");
+var import_promises14 = require("fs/promises");
+var import_path21 = require("path");
 var import_semver = __toESM(require_semver2());
 var AutoVersioningException = class extends Error {
   /**
@@ -40577,10 +40873,17 @@ var AutoVersioningService = class _AutoVersioningService {
     } else {
       command = `find "${workingDirectory}" -type f -not -path "*/.git/*" -exec sed -i '' '${sedCommand}' {} +`;
     }
-    await loggingExeca(this.logger, "bash", ["-c", command], {
-      cwd: workingDirectory,
-      doNotPipeOutput: true
-    });
+    try {
+      await loggingExeca(this.logger, "bash", ["-c", command], {
+        cwd: workingDirectory,
+        doNotPipeOutput: true
+      });
+    } catch (error) {
+      throw new CliError({
+        message: `Failed to replace placeholder version in generated files: ${extractErrorMessage(error)}`,
+        code: CliError.Code.UserError
+      });
+    }
     this.logger.debug("Placeholder version replaced successfully");
   }
   /**
@@ -40601,7 +40904,7 @@ var AutoVersioningService = class _AutoVersioningService {
       );
       return;
     }
-    const goModPath = (0, import_path18.join)(workingDirectory, "go.mod");
+    const goModPath = (0, import_path21.join)(workingDirectory, "go.mod");
     if (!(0, import_fs13.existsSync)(goModPath)) {
       this.logger.debug(`No go.mod found in ${workingDirectory}, skipping Go module path update`);
       return;
@@ -40635,7 +40938,7 @@ var AutoVersioningService = class _AutoVersioningService {
    * Reads the module path from a go.mod file.
    */
   async readGoModulePath(goModPath) {
-    const content = await (0, import_promises12.readFile)(goModPath, "utf-8");
+    const content = await (0, import_promises14.readFile)(goModPath, "utf-8");
     for (const line of content.split("\n")) {
       const trimmed2 = line.trim();
       if (trimmed2.startsWith("module ")) {
@@ -40648,7 +40951,7 @@ var AutoVersioningService = class _AutoVersioningService {
    * Adds a version suffix to the module line in go.mod.
    */
   async addSuffixToGoMod(goModPath, modulePath, suffix) {
-    const content = await (0, import_promises12.readFile)(goModPath, "utf-8");
+    const content = await (0, import_promises14.readFile)(goModPath, "utf-8");
     const lines = content.split("\n");
     let changed = false;
     for (let i2 = 0; i2 < lines.length; i2++) {
@@ -40660,7 +40963,7 @@ var AutoVersioningService = class _AutoVersioningService {
       }
     }
     if (changed) {
-      await (0, import_promises12.writeFile)(goModPath, lines.join("\n"), "utf-8");
+      await (0, import_promises14.writeFile)(goModPath, lines.join("\n"), "utf-8");
       this.logger.debug(`Updated go.mod: added ${suffix} to module path`);
     }
   }
@@ -40669,10 +40972,10 @@ var AutoVersioningService = class _AutoVersioningService {
    */
   async walkDirectory(dir, filter2) {
     const results = [];
-    const entries2 = await (0, import_promises12.readdir)(dir);
+    const entries2 = await (0, import_promises14.readdir)(dir);
     for (const entry of entries2) {
-      const fullPath = (0, import_path18.join)(dir, entry);
-      const entryStat = await (0, import_promises12.stat)(fullPath);
+      const fullPath = (0, import_path21.join)(dir, entry);
+      const entryStat = await (0, import_promises14.stat)(fullPath);
       if (entryStat.isDirectory()) {
         if (entry === ".git" || entry === "vendor") {
           continue;
@@ -40689,7 +40992,7 @@ var AutoVersioningService = class _AutoVersioningService {
    * Adds a version suffix to import paths in all .go files in the repository.
    */
   async addSuffixToGoFiles(repoRoot, modulePath, suffix) {
-    const goFiles = await this.walkDirectory(repoRoot, (filePath) => (0, import_path18.extname)(filePath) === ".go");
+    const goFiles = await this.walkDirectory(repoRoot, (filePath) => (0, import_path21.extname)(filePath) === ".go");
     for (const filePath of goFiles) {
       await this.addSuffixToGoFile(filePath, modulePath, suffix);
     }
@@ -40699,7 +41002,7 @@ var AutoVersioningService = class _AutoVersioningService {
    * Replaces occurrences of the module path with modulePath + suffix in import statements.
    */
   async addSuffixToGoFile(filePath, modulePath, suffix) {
-    const content = await (0, import_promises12.readFile)(filePath, "utf-8");
+    const content = await (0, import_promises14.readFile)(filePath, "utf-8");
     const lines = content.split("\n");
     let changed = false;
     let inImportBlock = false;
@@ -40728,7 +41031,7 @@ var AutoVersioningService = class _AutoVersioningService {
       }
     }
     if (changed) {
-      await (0, import_promises12.writeFile)(filePath, lines.join("\n"), "utf-8");
+      await (0, import_promises14.writeFile)(filePath, lines.join("\n"), "utf-8");
       this.logger.debug(`Updated Go imports in ${filePath}`);
     }
   }
@@ -41134,7 +41437,7 @@ ${body}` : `${COMMIT_MARKER} ${subject}`;
   }
   async prependChangelogEntry(params) {
     const { version: version2, entry } = params;
-    const changelogPath = (0, import_path19.join)(this.outputDir, "changelog.md");
+    const changelogPath = (0, import_path22.join)(this.outputDir, "changelog.md");
     const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const header = `## [${version2}] - ${now}
 `;
@@ -41143,7 +41446,7 @@ ${body}` : `${COMMIT_MARKER} ${subject}`;
 `;
     let existing = "";
     if ((0, import_fs14.existsSync)(changelogPath)) {
-      existing = await (0, import_promises13.readFile)(changelogPath, "utf-8");
+      existing = await (0, import_promises15.readFile)(changelogPath, "utf-8");
     }
     let output;
     if (existing.trim().length === 0) {
@@ -41160,7 +41463,7 @@ ${newBlock}${remainder}`;
     } else {
       output = `${newBlock}${existing}`;
     }
-    await (0, import_promises13.writeFile)(changelogPath, output, "utf-8");
+    await (0, import_promises15.writeFile)(changelogPath, output, "utf-8");
   }
   brandMessage(message) {
     if (this.config.isWhitelabel) {
@@ -41383,8 +41686,8 @@ function tryRevParse(cwd2, rev) {
 }
 
 // src/pipeline/steps/GithubStep.ts
-var import_promises14 = require("fs/promises");
-var import_path20 = require("path");
+var import_promises16 = require("fs/promises");
+var import_path23 = require("path");
 
 // src/pipeline/github/createReplayBranch.ts
 async function createReplayBranch(repository, branchName, commitMessage, replayConflictInfo, logger) {
@@ -41531,6 +41834,7 @@ async function pushSignedCommit({
   branch,
   force,
   rebaseOnConflict = false,
+  author,
   logger
 }) {
   const tempRef = `refs/temp/fern-${Date.now()}`;
@@ -41545,12 +41849,18 @@ async function pushSignedCommit({
     await repository.pushObjectToRef(localHeadSha, tempRef);
     tempRefPushed = true;
     for (let attempt2 = 0; attempt2 < MAX_CONCURRENT_PUSH_RETRIES; attempt2++) {
+      const commitAuthor = {
+        name: author?.name ?? FERN_BOT_NAME2,
+        email: author?.email ?? FERN_BOT_EMAIL2
+      };
       const { data: signedCommit } = await octokit.git.createCommit({
         owner,
         repo,
         message,
         tree: treeSha,
-        parents
+        parents,
+        author: commitAuthor,
+        committer: commitAuthor
       });
       const signedSha = signedCommit.sha;
       try {
@@ -41876,6 +42186,7 @@ var GithubStep = class extends BaseStep {
         repo,
         branch: prBranch,
         force: isUpdatingExistingPR,
+        author: this.config.author,
         logger: this.logger
       });
       const pushedBranch = await repository.getCurrentBranch();
@@ -41998,6 +42309,7 @@ var GithubStep = class extends BaseStep {
         branch: baseBranch,
         force: false,
         rebaseOnConflict: true,
+        author: this.config.author,
         logger: this.logger
       });
       const pushedBranch = await repository.getCurrentBranch();
@@ -42015,13 +42327,13 @@ var GithubStep = class extends BaseStep {
   }
   async ensureFernignore() {
     this.logger.debug("Checking for .fernignore file...");
-    const fernignorePath = (0, import_path20.join)(this.outputDir, ".fernignore");
+    const fernignorePath = (0, import_path23.join)(this.outputDir, ".fernignore");
     try {
-      await (0, import_promises14.access)(fernignorePath);
+      await (0, import_promises16.access)(fernignorePath);
       this.logger.debug(".fernignore already exists");
     } catch {
       this.logger.debug("Creating .fernignore file...");
-      await (0, import_promises14.writeFile)(fernignorePath, "# Specify files that shouldn't be modified by Fern\n", "utf-8");
+      await (0, import_promises16.writeFile)(fernignorePath, "# Specify files that shouldn't be modified by Fern\n", "utf-8");
     }
   }
   deriveSkipCommit(replayResult) {
@@ -42232,7 +42544,7 @@ var ReplayStep = class extends BaseStep {
 };
 
 // ../cli/generation/local-generation/docker-utils/lib/runDocker.js
-var import_promises15 = require("fs/promises");
+var import_promises17 = require("fs/promises");
 var import_tmp_promise3 = __toESM(require_tmp_promise(), 1);
 async function pullImage(imageName, runner, signal) {
   await loggingExeca(void 0, runner ?? "docker", ["pull", imageName], {
@@ -42279,7 +42591,7 @@ async function execInContainer({ logger, containerId, command, runner, writeLogs
   const logs = stdout + stderr;
   if (writeLogsToFile) {
     const tmpFile = await import_tmp_promise3.default.file();
-    await (0, import_promises15.writeFile)(tmpFile.path, logs);
+    await (0, import_promises17.writeFile)(tmpFile.path, logs);
     logger.info(`Generator logs here: ${tmpFile.path}`);
   }
   const resolvedExitCode = exitCode ?? 1;
@@ -42310,63 +42622,9 @@ async function stopContainer({ logger, containerId, runner }) {
   });
 }
 
-// ../cli/logger/lib/LogLevel.js
-var LogLevel2 = {
-  Trace: "trace",
-  Debug: "debug",
-  Info: "info",
-  Warn: "warn",
-  Error: "error"
-};
-var LOG_LEVELS = Object.values(LogLevel2);
-
-// ../cli/logger/lib/createLogger.js
-var LoggerImpl = class {
-  log;
-  enabled;
-  constructor(log, enabled = true) {
-    this.log = log;
-    this.enabled = enabled;
-  }
-  disable() {
-    this.enabled = false;
-  }
-  enable() {
-    this.enabled = true;
-  }
-  debug(...args) {
-    if (this.enabled) {
-      this.log(LogLevel2.Debug, ...args);
-    }
-  }
-  info(...args) {
-    if (this.enabled) {
-      this.log(LogLevel2.Info, ...args);
-    }
-  }
-  warn(...args) {
-    if (this.enabled) {
-      this.log(LogLevel2.Warn, ...args);
-    }
-  }
-  error(...args) {
-    if (this.enabled) {
-      this.log(LogLevel2.Error, ...args);
-    }
-  }
-  trace(...args) {
-    if (this.enabled) {
-      this.log(LogLevel2.Trace, ...args);
-    }
-  }
-};
-function createLogger4(log) {
-  return new LoggerImpl(log);
-}
-
 // src/pipeline/steps/VerificationStep.ts
 var import_fs15 = require("fs");
-var import_path21 = require("path");
+var import_path24 = require("path");
 var CONTAINER_WORKSPACE_PATH = "/workspace";
 var VERIFY_SCRIPT_RELATIVE_PATH = ".fern/verify.sh";
 var VERIFY_SCRIPT_CONTAINER_PATH = `${CONTAINER_WORKSPACE_PATH}/${VERIFY_SCRIPT_RELATIVE_PATH}`;
@@ -42382,7 +42640,7 @@ var VerificationStep = class extends BaseStep {
   generatorVersions;
   name = "verify";
   async execute(_context) {
-    const verifyScriptHostPath = (0, import_path21.join)(this.outputDir, VERIFY_SCRIPT_RELATIVE_PATH);
+    const verifyScriptHostPath = (0, import_path24.join)(this.outputDir, VERIFY_SCRIPT_RELATIVE_PATH);
     if (!(0, import_fs15.existsSync)(verifyScriptHostPath)) {
       return { executed: true, success: true, skipped: true };
     }
@@ -42655,7 +42913,7 @@ void yargs_default(hideBin(process.argv)).scriptName(process.env.CLI_NAME ?? "ge
     const readmeConfig = await loadReadmeConfig({
       absolutePathToConfig: resolve(wd, argv.config)
     });
-    const originalReadmeContent = argv.originalReadme != null ? await (0, import_promises16.readFile)(argv.originalReadme, "utf8") : void 0;
+    const originalReadmeContent = argv.originalReadme != null ? await (0, import_promises18.readFile)(argv.originalReadme, "utf8") : void 0;
     await generateReadmeToStream({
       originalReadmeContent,
       readmeConfig,
@@ -42783,7 +43041,7 @@ void yargs_default(hideBin(process.argv)).scriptName(process.env.CLI_NAME ?? "ge
       try {
         const wd = cwd();
         const configValue = argv.config;
-        const configContent = configValue === STDIN_MARKER ? await readStdin() : configValue.trimStart().startsWith("{") ? configValue : await (0, import_promises16.readFile)(resolve(wd, configValue), "utf-8");
+        const configContent = configValue === STDIN_MARKER ? await readStdin() : configValue.trimStart().startsWith("{") ? configValue : await (0, import_promises18.readFile)(resolve(wd, configValue), "utf-8");
         let config;
         try {
           config = JSON.parse(configContent);
@@ -43079,7 +43337,7 @@ async function createWriteStream(outputPath) {
 }
 async function createWriteStreamFromFile(filepath) {
   if (!await doesPathExist(filepath)) {
-    await (0, import_promises16.mkdir)(import_path22.default.dirname(filepath), { recursive: true });
+    await (0, import_promises18.mkdir)(import_path25.default.dirname(filepath), { recursive: true });
   }
   return import_fs16.default.createWriteStream(filepath);
 }