@fern-api/generator-cli 0.9.19 → 0.9.21

package/dist/cli.js

@@ -7078,7 +7078,7 @@ 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 join12 = require("path").join;
+    var join14 = require("path").join;
     var resolve8 = require("path").resolve;
     var dirname4 = require("path").dirname;
     var defaultOptions2 = {
@@ -7115,7 +7115,7 @@ var require_require_directory = __commonJS({
       }
       path5 = !path5 ? dirname4(m.filename) : resolve8(dirname4(m.filename), path5);
       fs3.readdirSync(path5).forEach(function(filename) {
-        var joined = join12(path5, filename), files, key, obj;
+        var joined = join14(path5, filename), files, key, obj;
         if (fs3.statSync(joined).isDirectory() && options.recurse) {
           files = requireDirectory(m, joined, options);
           if (Object.keys(files).length) {
@@ -18885,7 +18885,7 @@ var require_resolve_block_scalar = __commonJS({
       if (!header)
         return { value: "", type: null, comment: "", range: [start, start, start] };
       const type = header.mode === ">" ? Scalar.Scalar.BLOCK_FOLDED : Scalar.Scalar.BLOCK_LITERAL;
-      const lines = scalar.source ? splitLines(scalar.source) : [];
+      const lines = scalar.source ? splitLines2(scalar.source) : [];
       let chompStart = lines.length;
       for (let i = lines.length - 1; i >= 0; --i) {
         const content = lines[i][1];
@@ -19043,7 +19043,7 @@ var require_resolve_block_scalar = __commonJS({
       }
       return { mode, indent, chomp, comment, length };
     }
-    function splitLines(source) {
+    function splitLines2(source) {
       const split = source.split(/\n( *)/);
       const first2 = split[0];
       const m = first2.match(/^( *)/);
@@ -22028,7 +22028,7 @@ var init_diff3 = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/@fern-api+replay@0.12.0/node_modules/@fern-api/replay/dist/index.js
+// ../../node_modules/.pnpm/@fern-api+replay@0.14.0/node_modules/@fern-api/replay/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
   CREDENTIAL_PATTERNS: () => CREDENTIAL_PATTERNS,
@@ -22401,11 +22401,43 @@ function threeWayMerge(base, ours, theirs) {
       }
     }
   }
-  return {
+  const result = {
     content: outputLines.join("\n"),
     hasConflicts: conflicts2.length > 0,
     conflicts: conflicts2
   };
+  if (conflicts2.length === 0) {
+    const dropped = computeDroppedContextLines(baseLines, theirsLines, outputLines);
+    if (dropped.length > 0) {
+      result.droppedContextLines = dropped;
+    }
+  }
+  return result;
+}
+function computeDroppedContextLines(baseLines, theirsLines, mergedLines) {
+  const baseCounts = countLines(baseLines);
+  const theirsCounts = countLines(theirsLines);
+  const mergedCounts = countLines(mergedLines);
+  const dropped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of baseLines) {
+    if (seen.has(line)) continue;
+    const inBase = baseCounts.get(line) ?? 0;
+    const inTheirs = theirsCounts.get(line) ?? 0;
+    const inMerged = mergedCounts.get(line) ?? 0;
+    if (inBase > 0 && inTheirs > 0 && inMerged < Math.min(inBase, inTheirs)) {
+      dropped.push(line);
+      seen.add(line);
+    }
+  }
+  return dropped;
+}
+function countLines(lines) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    counts.set(line, (counts.get(line) ?? 0) + 1);
+  }
+  return counts;
 }
 function tryResolveConflict(oursLines, baseLines, theirsLines) {
   if (baseLines.length === 0) {
@@ -22535,10 +22567,346 @@ function isBinaryFile(filePath) {
   const ext2 = (0, import_path8.extname)(filePath).toLowerCase();
   return BINARY_EXTENSIONS.has(ext2);
 }
+function computeDroppedContextLinesForFile(base, theirs, finalContent) {
+  const baseLines = base.split("\n");
+  const theirsLines = theirs.split("\n");
+  const finalLines = finalContent.split("\n");
+  const baseCounts = /* @__PURE__ */ new Map();
+  const theirsCounts = /* @__PURE__ */ new Map();
+  const finalCounts = /* @__PURE__ */ new Map();
+  for (const l of baseLines) baseCounts.set(l, (baseCounts.get(l) ?? 0) + 1);
+  for (const l of theirsLines) theirsCounts.set(l, (theirsCounts.get(l) ?? 0) + 1);
+  for (const l of finalLines) finalCounts.set(l, (finalCounts.get(l) ?? 0) + 1);
+  const dropped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of baseLines) {
+    if (seen.has(line)) continue;
+    const inBase = baseCounts.get(line) ?? 0;
+    const inTheirs = theirsCounts.get(line) ?? 0;
+    const inFinal = finalCounts.get(line) ?? 0;
+    if (inBase > 0 && inTheirs > 0 && inFinal < Math.min(inBase, inTheirs)) {
+      dropped.push(line);
+      seen.add(line);
+    }
+  }
+  return dropped;
+}
 function isDiffLineForFile(diffLine, filePath) {
   const match2 = diffLine.match(/^diff --git a\/.+ b\/(.+)$/);
   return match2 !== null && match2[1] === filePath;
 }
+function normalizeHunkBody(hunk) {
+  let contextC = 0;
+  let removeC = 0;
+  let addC = 0;
+  const trimmed2 = [];
+  for (const line of hunk.lines) {
+    const oldUsed = contextC + removeC;
+    const newUsed = contextC + addC;
+    if (oldUsed >= hunk.oldCount && newUsed >= hunk.newCount) break;
+    trimmed2.push(line);
+    if (line.type === "context") contextC++;
+    else if (line.type === "remove") removeC++;
+    else if (line.type === "add") addC++;
+  }
+  return { ...hunk, lines: trimmed2 };
+}
+function extractFileDiffForFile(patchContent, filePath) {
+  const lines = patchContent.split("\n");
+  const out = [];
+  let inTarget = false;
+  for (const line of lines) {
+    if (line.startsWith("diff --git")) {
+      if (inTarget) break;
+      if (isDiffLineForFile2(line, filePath)) {
+        inTarget = true;
+        out.push(line);
+      }
+      continue;
+    }
+    if (inTarget) out.push(line);
+  }
+  return out.length > 0 ? out.join("\n") + "\n" : null;
+}
+function isDiffLineForFile2(line, filePath) {
+  const match2 = line.match(/^diff --git a\/(.+) b\/(.+)$/);
+  return match2 !== null && (match2[2] === filePath || match2[1] === filePath);
+}
+async function computePerPatchDiff(patch, getCurrentGenContent, getWorkingTreeContent) {
+  const fragments = [];
+  const unlocatableFiles = [];
+  for (const file of patch.files) {
+    const fileDiff = extractFileDiffForFile(patch.patch_content, file);
+    if (fileDiff == null) {
+      unlocatableFiles.push(file);
+      continue;
+    }
+    const hunksRaw = parseHunks(fileDiff).map(normalizeHunkBody);
+    const hunks = hunksRaw.filter((h) => {
+      if (h.lines.length === 0) return false;
+      let ctx = 0, rm3 = 0, add = 0;
+      for (const ln of h.lines) {
+        if (ln.type === "context") ctx++;
+        else if (ln.type === "remove") rm3++;
+        else if (ln.type === "add") add++;
+      }
+      return ctx + rm3 === h.oldCount && ctx + add === h.newCount;
+    });
+    if (hunks.length === 0) {
+      if (hunksRaw.length > 0) unlocatableFiles.push(file);
+      continue;
+    }
+    const currentGen = await getCurrentGenContent(file);
+    const workingTree = await getWorkingTreeContent(file);
+    const isPureNewFile = hunks.every((h) => h.oldCount === 0);
+    const isPureDelete = hunks.every((h) => h.newCount === 0);
+    if (currentGen == null) {
+      if (!isPureNewFile) {
+        unlocatableFiles.push(file);
+        continue;
+      }
+      if (workingTree == null) continue;
+      fragments.push(synthesizeNewFileDiff(file, workingTree));
+      continue;
+    }
+    if (isPureNewFile) {
+      if (workingTree == null) {
+        fragments.push(synthesizeDeleteFileDiff(file, currentGen));
+        continue;
+      }
+      if (workingTree === currentGen) {
+        continue;
+      }
+      const fullDiff = await unifiedDiff(currentGen, workingTree, file);
+      if (fullDiff && fullDiff.trim()) fragments.push(fullDiff);
+      continue;
+    }
+    if (workingTree == null) {
+      if (!isPureDelete) {
+        unlocatableFiles.push(file);
+        continue;
+      }
+      fragments.push(synthesizeDeleteFileDiff(file, currentGen));
+      continue;
+    }
+    const currentGenLines = splitLines(currentGen);
+    const workingTreeLines = splitLines(workingTree);
+    const locInCurrentGenRaw = locateHunksInOurs(hunks, currentGenLines);
+    const locInWorkingTreeRaw = locateHunksInOurs(hunks, workingTreeLines);
+    if (locInCurrentGenRaw == null || locInWorkingTreeRaw == null) {
+      unlocatableFiles.push(file);
+      continue;
+    }
+    const locInCurrentGen = locInCurrentGenRaw.map(
+      (l) => resolveSpan(l, currentGenLines, "old")
+    );
+    const locInWorkingTree = locInWorkingTreeRaw.map(
+      (l) => resolveSpan(l, workingTreeLines, "new")
+    );
+    const overlay = overlayRegions(
+      currentGenLines,
+      locInCurrentGen,
+      workingTreeLines,
+      locInWorkingTree
+    );
+    if (overlay === null) {
+      unlocatableFiles.push(file);
+      continue;
+    }
+    if (overlay === currentGen) {
+      continue;
+    }
+    const fileUnifiedDiff = await unifiedDiff(currentGen, overlay, file);
+    if (fileUnifiedDiff && fileUnifiedDiff.trim()) {
+      fragments.push(fileUnifiedDiff);
+    }
+  }
+  return {
+    diff: fragments.join(""),
+    unlocatableFiles
+  };
+}
+async function computePerPatchDiffWithFallback(patch, getCurrentGenContent, getWorkingTreeContent, runCumulativeDiff) {
+  const ppDiff = await computePerPatchDiff(
+    patch,
+    getCurrentGenContent,
+    getWorkingTreeContent
+  );
+  if (ppDiff.unlocatableFiles.length === 0) {
+    return { diff: ppDiff.diff, hadFallback: false, fallbackFiles: [] };
+  }
+  const cumulative = await runCumulativeDiff(ppDiff.unlocatableFiles);
+  if (cumulative === null) {
+    return null;
+  }
+  const merged = ppDiff.diff + (cumulative.trim() ? cumulative : "");
+  return { diff: merged, hadFallback: true, fallbackFiles: ppDiff.unlocatableFiles };
+}
+function splitLines(content) {
+  return content.split("\n");
+}
+function resolveSpan(loc, oursLines, prefer) {
+  const { hunk, oursOffset } = loc;
+  const oldSide = [];
+  const newSide = [];
+  for (const line of hunk.lines) {
+    if (line.type === "context") {
+      oldSide.push(line.content);
+      newSide.push(line.content);
+    } else if (line.type === "remove") {
+      oldSide.push(line.content);
+    } else if (line.type === "add") {
+      newSide.push(line.content);
+    }
+  }
+  const oldFits = sequenceMatches(oldSide, oursLines, oursOffset);
+  const newFits = sequenceMatches(newSide, oursLines, oursOffset);
+  if (prefer === "old") {
+    if (oldFits) return { ...loc, oursSpan: hunk.oldCount };
+    if (newFits) return { ...loc, oursSpan: hunk.newCount };
+  } else {
+    if (newFits) return { ...loc, oursSpan: hunk.newCount };
+    if (oldFits) return { ...loc, oursSpan: hunk.oldCount };
+  }
+  return loc;
+}
+function sequenceMatches(needle, haystack, offset) {
+  if (offset + needle.length > haystack.length) return false;
+  for (let i = 0; i < needle.length; i++) {
+    if (haystack[offset + i] !== needle[i]) return false;
+  }
+  return true;
+}
+function overlayRegions(currentGenLines, locInCurrentGen, workingTreeLines, locInWorkingTree) {
+  if (locInCurrentGen.length !== locInWorkingTree.length) {
+    return null;
+  }
+  const out = [];
+  let cursor = 0;
+  for (let i = 0; i < locInCurrentGen.length; i++) {
+    const cg = locInCurrentGen[i];
+    const wt = locInWorkingTree[i];
+    if (cg.oursOffset > cursor) {
+      out.push(...currentGenLines.slice(cursor, cg.oursOffset));
+    }
+    out.push(...workingTreeLines.slice(wt.oursOffset, wt.oursOffset + wt.oursSpan));
+    cursor = cg.oursOffset + cg.oursSpan;
+  }
+  if (cursor < currentGenLines.length) {
+    out.push(...currentGenLines.slice(cursor));
+  }
+  return out.join("\n");
+}
+async function unifiedDiff(beforeContent, afterContent, filePath) {
+  if (beforeContent === afterContent) return "";
+  const tmp3 = await (0, import_promises4.mkdtemp)((0, import_path10.join)((0, import_os2.tmpdir)(), "fern-replay-pp-"));
+  try {
+    const beforePath = (0, import_path10.join)(tmp3, "before");
+    const afterPath = (0, import_path10.join)(tmp3, "after");
+    await (0, import_promises4.writeFile)(beforePath, beforeContent, "utf-8");
+    await (0, import_promises4.writeFile)(afterPath, afterContent, "utf-8");
+    const raw = await runGitDiffNoIndex(beforePath, afterPath);
+    if (!raw.trim()) return "";
+    return rewriteDiffHeaders(raw, filePath);
+  } finally {
+    await (0, import_promises4.rm)(tmp3, { recursive: true, force: true });
+  }
+}
+function runGitDiffNoIndex(beforePath, afterPath) {
+  return new Promise((resolve22, reject) => {
+    const proc = (0, import_child_process3.spawn)("git", ["diff", "--no-index", "--", beforePath, afterPath]);
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (d) => stdout += d.toString());
+    proc.stderr.on("data", (d) => stderr += d.toString());
+    proc.on("close", (code) => {
+      if (code === 0 || code === 1) resolve22(stdout);
+      else reject(new Error(`git diff --no-index failed (code ${code}): ${stderr}`));
+    });
+  });
+}
+function rewriteDiffHeaders(raw, filePath) {
+  const lines = raw.split("\n");
+  const out = [];
+  let seenFirstHeader = false;
+  for (const line of lines) {
+    if (line.startsWith("diff --git ")) {
+      out.push(`diff --git a/${filePath} b/${filePath}`);
+      seenFirstHeader = true;
+      continue;
+    }
+    if (!seenFirstHeader) {
+      continue;
+    }
+    if (line.startsWith("--- ")) {
+      out.push(`--- a/${filePath}`);
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      out.push(`+++ b/${filePath}`);
+      continue;
+    }
+    out.push(line);
+  }
+  return out.join("\n");
+}
+function synthesizeNewFileDiff(file, content) {
+  const lines = content.split("\n");
+  const hasTrailingNewline = content.endsWith("\n");
+  const bodyLines = hasTrailingNewline ? lines.slice(0, -1) : lines;
+  const header = [
+    `diff --git a/${file} b/${file}`,
+    "new file mode 100644",
+    "--- /dev/null",
+    `+++ b/${file}`,
+    `@@ -0,0 +1,${bodyLines.length} @@`
+  ].join("\n");
+  const body = bodyLines.map((l) => `+${l}`).join("\n");
+  const trailer = hasTrailingNewline ? "" : "\n\";
+  return header + "\n" + body + trailer + "\n";
+}
+function synthesizeDeleteFileDiff(file, content) {
+  const lines = content.split("\n");
+  const hasTrailingNewline = content.endsWith("\n");
+  const bodyLines = hasTrailingNewline ? lines.slice(0, -1) : lines;
+  const header = [
+    `diff --git a/${file} b/${file}`,
+    "deleted file mode 100644",
+    `--- a/${file}`,
+    "+++ /dev/null",
+    `@@ -1,${bodyLines.length} +0,0 @@`
+  ].join("\n");
+  const body = bodyLines.map((l) => `-${l}`).join("\n");
+  const trailer = hasTrailingNewline ? "" : "\n\";
+  return header + "\n" + body + trailer + "\n";
+}
+function computeCommitBuckets(results, absorbedPatchIds, patchesPassedToCommit) {
+  const resultByPatchId = /* @__PURE__ */ new Map();
+  for (const r2 of results) resultByPatchId.set(r2.patch.id, r2);
+  const applied = [];
+  const unresolved = [];
+  const absorbed = [];
+  for (const patch of patchesPassedToCommit) {
+    if (absorbedPatchIds.has(patch.id)) {
+      absorbed.push(patch);
+      continue;
+    }
+    const r2 = resultByPatchId.get(patch.id);
+    if (!r2) {
+      applied.push(patch);
+      continue;
+    }
+    if (r2.status === "conflict" || patch.status === "unresolved") {
+      unresolved.push(patch);
+      continue;
+    }
+    if (r2.status === "applied") {
+      applied.push(patch);
+      continue;
+    }
+  }
+  return { applied, unresolved, absorbed };
+}
 async function bootstrap(outputDir, options) {
   const git = new GitClient(outputDir);
   const lockManager = new LockfileManager(outputDir);
@@ -22703,7 +23071,7 @@ function parseGitLog(log) {
   });
 }
 function ensureFernignoreEntries(outputDir) {
-  const fernignorePath = (0, import_path11.join)(outputDir, ".fernignore");
+  const fernignorePath = (0, import_path12.join)(outputDir, ".fernignore");
   let content = "";
   if ((0, import_fs9.existsSync)(fernignorePath)) {
     content = (0, import_fs9.readFileSync)(fernignorePath, "utf-8");
@@ -22726,7 +23094,7 @@ function ensureFernignoreEntries(outputDir) {
   return true;
 }
 function ensureGitattributesEntries(outputDir) {
-  const gitattributesPath = (0, import_path11.join)(outputDir, ".gitattributes");
+  const gitattributesPath = (0, import_path12.join)(outputDir, ".gitattributes");
   let content = "";
   if ((0, import_fs9.existsSync)(gitattributesPath)) {
     content = (0, import_fs9.readFileSync)(gitattributesPath, "utf-8");
@@ -22921,7 +23289,7 @@ async function resolve7(outputDir, options) {
   const resolvingPatches = lockManager.getResolvingPatches();
   if (unresolvedPatches.length > 0) {
     const applicator = new ReplayApplicator(git, lockManager, outputDir);
-    await applicator.applyPatches(unresolvedPatches);
+    await applicator.applyPatches(unresolvedPatches, { applyMode: "resolve" });
     const markerFiles = await findConflictMarkerFiles(git);
     if (markerFiles.length > 0) {
       for (const patch of unresolvedPatches) {
@@ -22947,20 +23315,38 @@ async function resolve7(outputDir, options) {
   if (patchesToCommit.length > 0) {
     const currentGen = lock.current_generation;
     const detector = new ReplayDetector(git, lockManager, outputDir);
+    const warnings = [];
     let patchesResolved = 0;
     for (const patch of patchesToCommit) {
-      const diff = await git.exec(["diff", currentGen, "--", ...patch.files]).catch(() => null);
-      if (!diff || !diff.trim()) {
+      const result = await computePerPatchDiffWithFallback(
+        patch,
+        (f2) => git.showFile(currentGen, f2),
+        (f2) => (0, import_promises5.readFile)((0, import_path13.join)(outputDir, f2), "utf-8").catch(() => null),
+        (files) => git.exec(["diff", currentGen, "--", ...files]).catch(() => null)
+      );
+      if (result === null) {
+        warnings.push(
+          `Patch ${patch.id}: cumulative-diff fallback failed for unlocatable files; preserving patch unchanged`
+        );
+        continue;
+      }
+      const diff = result.diff;
+      if (!diff.trim()) {
         lockManager.removePatch(patch.id);
         continue;
       }
+      if (result.hadFallback) {
+        warnings.push(
+          `Patch ${patch.id}: ${result.fallbackFiles.join(", ")} could not be anchored; cumulative-diff fallback applied for those files`
+        );
+      }
       const newContentHash = detector.computeContentHash(diff);
-      const changedFiles = await getChangedFiles(git, currentGen, patch.files);
+      const changedFiles = result.hadFallback ? await getChangedFiles(git, currentGen, patch.files) : extractFilesFromDiff(diff);
       lockManager.markPatchResolved(patch.id, {
         patch_content: diff,
         content_hash: newContentHash,
         base_generation: currentGen,
-        files: changedFiles
+        files: changedFiles.length > 0 ? changedFiles : patch.files
       });
       patchesResolved++;
     }
@@ -22976,7 +23362,8 @@ async function resolve7(outputDir, options) {
       success: true,
       commitSha: commitSha2,
       phase: "committed",
-      patchesResolved
+      patchesResolved,
+      warnings: warnings.length > 0 ? warnings : void 0
     };
   }
   const committer = new ReplayCommitter(git, outputDir);
@@ -22994,6 +23381,24 @@ async function getChangedFiles(git, currentGen, files) {
   const changed = filesOutput.trim().split("\n").filter(Boolean).filter((f2) => !f2.startsWith(".fern/"));
   return changed.length > 0 ? changed : files;
 }
+function extractFilesFromDiff(unifiedDiff2) {
+  const out = /* @__PURE__ */ new Set();
+  const renameSources = /* @__PURE__ */ new Set();
+  let currentTarget = null;
+  for (const line of unifiedDiff2.split("\n")) {
+    const headerMatch = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+    if (headerMatch) {
+      currentTarget = headerMatch[2];
+      if (!currentTarget.startsWith(".fern/")) out.add(currentTarget);
+      continue;
+    }
+    if (currentTarget && line.startsWith("rename from ")) {
+      renameSources.add(line.slice("rename from ".length));
+    }
+  }
+  for (const src of renameSources) out.delete(src);
+  return Array.from(out);
+}
 function status(outputDir) {
   const lockManager = new LockfileManager(outputDir);
   if (!lockManager.exists()) {
@@ -23041,9 +23446,9 @@ function status(outputDir) {
     excludePatterns
   };
 }
-var import_fs6, import_path7, import_yaml, import_crypto, import_promises3, import_os, import_path8, import_fs7, import_path9, import_crypto2, import_fs8, import_path10, import_yaml2, import_crypto3, import_fs9, import_path11, import_fs10, __defProp3, __getOwnPropNames3, __esm3, __export3, GitClient_exports, GitClient, init_GitClient, HybridReconstruction_exports, init_HybridReconstruction, CREDENTIAL_PATTERNS, SENSITIVE_FILE_PATTERNS, FERN_BOT_NAME, FERN_BOT_EMAIL, FERN_BOT_LOGIN, FERN_SUPPORT_NAMES, LOCKFILE_HEADER, LockfileNotFoundError, LockfileManager, INFRASTRUCTURE_FILES, ReplayDetector, CONFLICT_OPENER, CONFLICT_SEPARATOR, CONFLICT_CLOSER, BINARY_EXTENSIONS, ReplayApplicator, ReplayCommitter, ReplayService, FernignoreMigrator, REPLAY_FERNIGNORE_ENTRIES, GITATTRIBUTES_ENTRIES, EMPTY_RESULT;
+var import_fs6, import_path7, import_yaml, import_crypto, import_promises3, import_os, import_path8, import_fs7, import_path9, import_promises4, import_os2, import_path10, import_child_process3, import_crypto2, import_fs8, import_path11, import_yaml2, import_crypto3, import_fs9, import_path12, import_fs10, import_promises5, import_path13, __defProp3, __getOwnPropNames3, __esm3, __export3, GitClient_exports, GitClient, init_GitClient, HybridReconstruction_exports, init_HybridReconstruction, CREDENTIAL_PATTERNS, SENSITIVE_FILE_PATTERNS, FERN_BOT_NAME, FERN_BOT_EMAIL, FERN_BOT_LOGIN, FERN_SUPPORT_NAMES, LOCKFILE_HEADER, LockfileNotFoundError, LockfileManager, INFRASTRUCTURE_FILES, ReplayDetector, CONFLICT_OPENER, CONFLICT_SEPARATOR, CONFLICT_CLOSER, BINARY_EXTENSIONS, ReplayApplicator, ReplayCommitter, ReplayService, FernignoreMigrator, REPLAY_FERNIGNORE_ENTRIES, GITATTRIBUTES_ENTRIES, EMPTY_RESULT;
 var init_dist3 = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.12.0/node_modules/@fern-api/replay/dist/index.js"() {
+  "../../node_modules/.pnpm/@fern-api+replay@0.14.0/node_modules/@fern-api/replay/dist/index.js"() {
     "use strict";
     init_esm4();
     import_fs6 = require("fs");
@@ -23058,16 +23463,22 @@ var init_dist3 = __esm({
     import_fs7 = require("fs");
     import_path9 = require("path");
     init_esm3();
+    import_promises4 = require("fs/promises");
+    import_os2 = require("os");
+    import_path10 = require("path");
+    import_child_process3 = require("child_process");
     import_crypto2 = require("crypto");
     import_fs8 = require("fs");
-    import_path10 = require("path");
+    import_path11 = require("path");
     init_esm3();
     import_yaml2 = __toESM(require_dist3(), 1);
     import_crypto3 = require("crypto");
     import_fs9 = require("fs");
-    import_path11 = require("path");
+    import_path12 = require("path");
     init_esm3();
     import_fs10 = require("fs");
+    import_promises5 = require("fs/promises");
+    import_path13 = require("path");
     __defProp3 = Object.defineProperty;
     __getOwnPropNames3 = Object.getOwnPropertyNames;
     __esm3 = (fn, res) => function __init() {
@@ -23095,9 +23506,9 @@ var init_dist3 = __esm({
             return this.git.raw(args);
           }
           async execWithInput(args, input) {
-            const { spawn: spawn2 } = await import("child_process");
+            const { spawn: spawn22 } = await import("child_process");
             return new Promise((resolve22, reject) => {
-              const proc = spawn2("git", args, { cwd: this.repoPath });
+              const proc = spawn22("git", args, { cwd: this.repoPath });
               let stdout = "";
               let stderr = "";
               proc.stdout.on("data", (data) => {
@@ -23457,17 +23868,57 @@ var init_dist3 = __esm({
         }
         const isAncestor = await this.git.isAncestor(lastGen.commit_sha, "HEAD");
         if (!isAncestor) {
+          return this.detectPatchesViaMergeBase(lastGen, lock);
+        }
+        return this.detectPatchesInRange(lastGen.commit_sha, lastGen, lock);
+      }
+      /**
+       * FER-10201 — Non-linear-history detection via `merge-base(prevGen, HEAD)`.
+       *
+       * After a squash-merge of a Fern-bot PR, `lastGen.commit_sha` (the previous
+       * `[fern-generated]`) is orphaned but still in git's object database. The
+       * merge-base is the commit on main from which the bot's branch was created —
+       * a reachable ancestor of HEAD. Walking that range and classifying each
+       * commit via `isGenerationCommit` mirrors the linear path and eliminates
+       * the bug class where pipeline-driven changes (autoversion, replay,
+       * generation) get bundled as customer customizations.
+       *
+       * Falls through to the legacy composite path when no common ancestor exists
+       * (truly disjoint history — orphan branches with no shared root).
+       */
+      async detectPatchesViaMergeBase(lastGen, lock) {
+        let mergeBase = "";
+        try {
+          mergeBase = (await this.git.exec(["merge-base", lastGen.commit_sha, "HEAD"])).trim();
+        } catch {
+        }
+        if (!mergeBase) {
+          this.warnings.push(
+            `No common ancestor between previous generation ${lastGen.commit_sha.slice(0, 7)} and HEAD. Falling back to composite tree-diff detection.`
+          );
           return this.detectPatchesViaTreeDiff(
             lastGen,
             /* commitKnownMissing */
             false
           );
         }
+        return this.detectPatchesInRange(mergeBase, lastGen, lock);
+      }
+      /**
+       * FER-10201 — Walk `${rangeStart}..HEAD`, classify each commit, emit one
+       * `StoredPatch` per customer commit. Body shared by the linear path
+       * (rangeStart = lastGen.commit_sha) and the merge-base path.
+       *
+       * Patch `base_generation` is always `lastGen.commit_sha` — the
+       * lockfile-tracked reference the applicator uses to fetch base file
+       * content, regardless of where the walk actually started.
+       */
+      async detectPatchesInRange(rangeStart, lastGen, lock) {
         const log = await this.git.exec([
           "log",
           "--first-parent",
           "--format=%H%x00%an%x00%ae%x00%s",
-          `${lastGen.commit_sha}..HEAD`,
+          `${rangeStart}..HEAD`,
           "--",
           this.sdkOutputDir
         ]);
@@ -23981,6 +24432,19 @@ var init_dist3 = __esm({
       renameCache = /* @__PURE__ */ new Map();
       treeExistsCache = /* @__PURE__ */ new Map();
       fileTheirsAccumulator = /* @__PURE__ */ new Map();
+      /**
+       * Apply mode for the current `applyPatches` invocation. Set at the start
+       * of `applyPatches`, read by `mergeFile` to decide:
+       *   - whether to skip the intra-loop marker strip (kept in `applyPatches`)
+       *   - whether to populate the accumulator after a conflicted merge
+       *     (resolve mode populates so subsequent patches on the same file
+       *     can use patch A's THEIRS as a structurally-correct merge base
+       *     when their diff was authored against post-A structure)
+       *   - whether to retry THEIRS reconstruction against the accumulator
+       *     when the BASE-relative reconstruction produced markers from a
+       *     cross-patch context mismatch
+       */
+      currentApplyMode = "replay";
       constructor(git, lockManager, outputDir) {
         this.git = git;
         this.lockManager = lockManager;
@@ -24028,8 +24492,23 @@ var init_dist3 = __esm({
       /**
        * 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) {
+      async applyPatches(patches, opts) {
+        const applyMode = opts?.applyMode ?? "replay";
+        this.currentApplyMode = applyMode;
         this.resetAccumulator();
         const results = [];
         for (let i = 0; i < patches.length; i++) {
@@ -24044,7 +24523,7 @@ var init_dist3 = __esm({
           }
           const result = await this.applyPatchWithFallback(patch);
           results.push(result);
-          if (result.status === "conflict" && result.fileResults) {
+          if (applyMode !== "resolve" && result.status === "conflict" && result.fileResults) {
             const laterFiles = /* @__PURE__ */ new Set();
             for (let j2 = i + 1; j2 < patches.length; j2++) {
               for (const f2 of patches[j2].files) {
@@ -24074,9 +24553,17 @@ var init_dist3 = __esm({
         }
         return results;
       }
-      /** Populate accumulator after git apply succeeds. */
+      /**
+       * Populate accumulator after git apply succeeds, AND collect per-file
+       * results including any "dropped context lines" — lines that were
+       * present in BASE and THEIRS (unchanged context) but absent from the
+       * final on-disk state because OURS deleted them. This is the fast-path
+       * counterpart to ThreeWayMerge.computeDroppedContextLines used by the
+       * 3-way slow path; both must surface the same warning.
+       */
       async populateAccumulatorForPatch(patch, baseGen, currentTreeHash) {
-        if (!baseGen) return;
+        const fileResults = [];
+        if (!baseGen) return fileResults;
         const tempDir = await (0, import_promises3.mkdtemp)((0, import_path8.join)((0, import_os.tmpdir)(), "replay-acc-"));
         const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
         const tempGit = new GitClient2(tempDir);
@@ -24089,18 +24576,30 @@ var init_dist3 = __esm({
             const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
             const base = await this.git.showFile(baseGen.tree_hash, filePath);
             const theirs = await this.applyPatchToContent(base, patch.patch_content, filePath, tempGit, tempDir);
-            const effectiveTheirs = theirs ?? await (0, import_promises3.readFile)((0, import_path8.join)(this.outputDir, resolvedPath), "utf-8").catch(() => null);
+            const finalOnDisk = await (0, import_promises3.readFile)((0, import_path8.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_promises3.rm)(tempDir, { recursive: true }).catch(() => {
           });
         }
+        return fileResults;
       }
       async applyPatchWithFallback(patch) {
         const baseGen = await this.resolveBaseGeneration(patch.base_generation);
@@ -24131,11 +24630,12 @@ var init_dist3 = __esm({
           }
           try {
             await this.git.execWithInput(["apply", "--3way"], patch.patch_content);
-            await this.populateAccumulatorForPatch(patch, baseGen, currentTreeHash);
+            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 {
@@ -24247,19 +24747,23 @@ var init_dist3 = __esm({
               renameSourcePath
             );
           }
+          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) {
-              return {
-                file: resolvedPath,
-                status: "skipped",
-                reason: "stale-conflict-markers"
-              };
+              if (accumulatorEntry) {
+                theirs = null;
+              } else {
+                return {
+                  file: resolvedPath,
+                  status: "skipped",
+                  reason: "stale-conflict-markers"
+                };
+              }
             }
           }
           let useAccumulatorAsMergeBase = false;
-          const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
           if (accumulatorEntry && (theirs == null || base == null)) {
             theirs = await this.applyPatchToContent(
               accumulatorEntry.content,
@@ -24366,7 +24870,8 @@ var init_dist3 = __esm({
           const outDir = (0, import_path8.dirname)(oursPath);
           await (0, import_promises3.mkdir)(outDir, { recursive: true });
           await (0, import_promises3.writeFile)(oursPath, merged.content);
-          if (effective_theirs != null && !merged.hasConflicts) {
+          const populateAccumulator = effective_theirs != null && (!merged.hasConflicts || this.currentApplyMode === "resolve");
+          if (populateAccumulator) {
             this.fileTheirsAccumulator.set(resolvedPath, {
               content: effective_theirs,
               baseGeneration: patch.base_generation
@@ -24381,7 +24886,11 @@ var init_dist3 = __esm({
               conflictMetadata: metadata
             };
           }
-          return { file: resolvedPath, status: "merged" };
+          return {
+            file: resolvedPath,
+            status: "merged",
+            ...merged.droppedContextLines && merged.droppedContextLines.length > 0 ? { droppedContextLines: merged.droppedContextLines } : {}
+          };
         } catch (error) {
           return {
             file: filePath,
@@ -24592,13 +25101,46 @@ CLI Version: ${options.cliVersion}`;
         await this.git.exec(["commit", "-m", fullMessage]);
         return (await this.git.exec(["rev-parse", "HEAD"])).trim();
       }
-      async commitReplay(_patchCount, patches, message) {
+      async commitReplay(_patchCount, patches, message, options) {
         await this.stageAll();
         if (!await this.hasStagedChanges()) {
           return (await this.git.exec(["rev-parse", "HEAD"])).trim();
         }
         let fullMessage = message ?? `[fern-replay] Applied customizations`;
-        if (patches && patches.length > 0) {
+        const buckets = options?.buckets;
+        if (buckets) {
+          if (buckets.applied.length > 0) {
+            fullMessage += `
+
+Patches applied (${buckets.applied.length}):`;
+            for (const p of buckets.applied) {
+              fullMessage += `
+  - ${p.id}: ${p.original_message}`;
+            }
+          }
+          if (buckets.unresolved.length > 0) {
+            fullMessage += `
+
+Patches with unresolved conflicts (${buckets.unresolved.length}):`;
+            for (const p of buckets.unresolved) {
+              fullMessage += `
+  - ${p.id}: ${p.original_message}`;
+            }
+            fullMessage += `
+    Run \`fern-replay resolve\` to apply these customizations.`;
+          }
+          if (buckets.absorbed.length > 0) {
+            fullMessage += `
+
+Patches absorbed by generator (${buckets.absorbed.length}):`;
+            for (const p of buckets.absorbed) {
+              fullMessage += `
+  - ${p.id}: ${p.original_message}`;
+            }
+            fullMessage += `
+    The generator now produces these customizations natively.`;
+          }
+        } else if (patches && patches.length > 0) {
           fullMessage += "\n\nPatches replayed:";
           for (const patch of patches) {
             fullMessage += `
@@ -24632,6 +25174,7 @@ CLI Version: ${options.cliVersion}`;
       }
     };
     init_GitClient();
+    init_HybridReconstruction();
     ReplayService = class {
       git;
       detector;
@@ -25025,6 +25568,7 @@ CLI Version: ${options.cliVersion}`;
         if (newPatches.length > 0) {
           results = await this.applicator.applyPatches(newPatches);
           this._lastApplyResults = results;
+          this.recordDroppedContextLineWarnings(results);
           this.revertConflictingFiles(results);
           for (const result of results) {
             if (result.status === "conflict") {
@@ -25043,7 +25587,8 @@ CLI Version: ${options.cliVersion}`;
         if (newPatches.length > 0) {
           if (!options?.stageOnly) {
             const appliedCount = results.filter((r2) => r2.status === "applied").length;
-            await this.committer.commitReplay(appliedCount, newPatches);
+            const buckets = computeCommitBuckets(results, rebaseCounts.absorbedPatchIds, newPatches);
+            await this.committer.commitReplay(appliedCount, newPatches, void 0, { buckets });
           } else {
             await this.committer.stageAll();
           }
@@ -25106,12 +25651,21 @@ CLI Version: ${options.cliVersion}`;
           (p) => preRebasePatchIds.has(p.id) && !postRebasePatchIds.has(p.id)
         );
         existingPatches = this.lockManager.getPatches();
-        const seenHashes = /* @__PURE__ */ new Set();
+        const seenHashes = /* @__PURE__ */ new Map();
         for (const p of existingPatches) {
-          if (seenHashes.has(p.content_hash)) {
-            this.lockManager.removePatch(p.id);
+          const priorOrigin = seenHashes.get(p.content_hash);
+          if (priorOrigin !== void 0) {
+            const provenanceMissing = !priorOrigin || !p.original_commit;
+            const sameOrigin = priorOrigin === p.original_commit;
+            if (sameOrigin && !provenanceMissing) {
+              this.lockManager.removePatch(p.id);
+            } else {
+              this.warnings.push(
+                `Preserving patch ${p.id} (commit ${(p.original_commit || "<missing>").slice(0, 7)}): shares content_hash with a prior patch ${provenanceMissing ? "(provenance missing on at least one side)" : "from a different source commit"}. Both retained to avoid silent customization loss (FER-9983).`
+              );
+            }
           } else {
-            seenHashes.add(p.content_hash);
+            seenHashes.set(p.content_hash, p.original_commit);
           }
         }
         existingPatches = this.lockManager.getPatches();
@@ -25172,6 +25726,7 @@ CLI Version: ${options.cliVersion}`;
         const genSha = prep._prepared.genSha;
         const results = await this.applicator.applyPatches(allPatches);
         this._lastApplyResults = results;
+        this.recordDroppedContextLineWarnings(results);
         this.revertConflictingFiles(results);
         for (const result of results) {
           if (result.status === "conflict") {
@@ -25199,7 +25754,8 @@ CLI Version: ${options.cliVersion}`;
           await this.committer.stageAll();
         } else {
           const appliedCount = results.filter((r2) => r2.status === "applied").length;
-          await this.committer.commitReplay(appliedCount, allPatches);
+          const buckets = computeCommitBuckets(results, rebaseCounts.absorbedPatchIds, allPatches);
+          await this.committer.commitReplay(appliedCount, allPatches, void 0, { buckets });
         }
         const warnings = [...detectorWarnings, ...this.warnings];
         return this.buildReport(
@@ -25223,7 +25779,7 @@ CLI Version: ${options.cliVersion}`;
         let repointed = 0;
         let contentRebased = 0;
         let keptAsUserOwned = 0;
-        const seenContentHashes = /* @__PURE__ */ new Set();
+        const seenContentHashes = /* @__PURE__ */ new Map();
         const absorbedPatchIds = /* @__PURE__ */ new Set();
         const fernignorePatterns = this.readFernignorePatterns();
         for (const result of results) {
@@ -25237,6 +25793,23 @@ CLI Version: ${options.cliVersion}`;
             }
           }
         }
+        const conflictedFilePaths = /* @__PURE__ */ new Set();
+        for (const r2 of results) {
+          if (r2.status !== "conflict") continue;
+          if (r2.fileResults) {
+            for (const fr of r2.fileResults) {
+              if (fr.status !== "conflict") continue;
+              conflictedFilePaths.add(fr.file);
+              if (r2.resolvedFiles) {
+                for (const [orig, resolved] of Object.entries(r2.resolvedFiles)) {
+                  if (resolved === fr.file) conflictedFilePaths.add(orig);
+                }
+              }
+            }
+          } else {
+            for (const f2 of r2.patch.files) conflictedFilePaths.add(f2);
+          }
+        }
         for (const result of results) {
           if (result.status === "conflict" && result.fileResults) {
             await this.trimAbsorbedFiles(result, currentGenSha);
@@ -25304,6 +25877,18 @@ CLI Version: ${options.cliVersion}`;
                 keptAsUserOwned++;
                 continue;
               }
+              const overlapsConflicted = patch.files.some((f2) => conflictedFilePaths.has(f2));
+              if (overlapsConflicted) {
+                patch.status = "unresolved";
+                try {
+                  this.lockManager.updatePatch(patch.id, { status: "unresolved" });
+                } catch {
+                }
+                this.warnings.push(
+                  `Patch ${patch.id} (${patch.original_message}) was preserved as unresolved because an earlier patch conflicted on the same file(s) (${patch.files.join(", ")}). Run \`fern replay resolve\` to apply this customization manually.`
+                );
+                continue;
+              }
               this.lockManager.removePatch(patch.id);
               absorbedPatchIds.add(patch.id);
               absorbed++;
@@ -25319,13 +25904,22 @@ CLI Version: ${options.cliVersion}`;
               continue;
             }
             const newContentHash = this.detector.computeContentHash(diff);
-            if (seenContentHashes.has(newContentHash)) {
-              this.lockManager.removePatch(patch.id);
-              absorbedPatchIds.add(patch.id);
-              absorbed++;
-              continue;
+            const priorOrigin = seenContentHashes.get(newContentHash);
+            if (priorOrigin !== void 0) {
+              const provenanceMissing = !priorOrigin || !patch.original_commit;
+              const sameOrigin = priorOrigin === patch.original_commit;
+              if (sameOrigin && !provenanceMissing) {
+                this.lockManager.removePatch(patch.id);
+                absorbedPatchIds.add(patch.id);
+                absorbed++;
+                continue;
+              }
+              this.warnings.push(
+                `Preserving patch ${patch.id} (commit ${(patch.original_commit || "<missing>").slice(0, 7)}): shares content_hash with a prior patch ${provenanceMissing ? "(provenance missing on at least one side)" : "from a different source commit"}. Both retained to avoid silent customization loss (FER-9983).`
+              );
+            } else {
+              seenContentHashes.set(newContentHash, patch.original_commit);
             }
-            seenContentHashes.add(newContentHash);
             patch.base_generation = currentGenSha;
             patch.patch_content = diff;
             patch.content_hash = newContentHash;
@@ -25501,8 +26095,14 @@ CLI Version: ${options.cliVersion}`;
           }
           if (patch.base_generation === currentGen) {
             try {
-              const diff = await this.git.exec(["diff", currentGen, "HEAD", "--", ...patch.files]).catch(() => null);
-              if (diff === null) continue;
+              const ppResult = await computePerPatchDiffWithFallback(
+                patch,
+                (f2) => this.git.showFile(currentGen, f2),
+                (f2) => this.git.showFile("HEAD", f2),
+                (files) => this.git.exec(["diff", currentGen, "HEAD", "--", ...files]).catch(() => null)
+              );
+              if (ppResult === null) continue;
+              const diff = ppResult.diff;
               if (!diff.trim()) {
                 if (await allPatchFilesUserOwned(patch)) continue;
                 this.lockManager.removePatch(patch.id);
@@ -25544,8 +26144,14 @@ CLI Version: ${options.cliVersion}`;
           try {
             const markerFiles = await this.git.exec(["grep", "-l", "<<<<<<< Generated", "HEAD", "--", ...patch.files]).catch(() => "");
             if (markerFiles.trim()) continue;
-            const diff = await this.git.exec(["diff", currentGen, "HEAD", "--", ...patch.files]).catch(() => null);
-            if (diff === null) continue;
+            const ppResult = await computePerPatchDiffWithFallback(
+              patch,
+              (f2) => this.git.showFile(currentGen, f2),
+              (f2) => this.git.showFile("HEAD", f2),
+              (files) => this.git.exec(["diff", currentGen, "HEAD", "--", ...files]).catch(() => null)
+            );
+            if (ppResult === null) continue;
+            const diff = ppResult.diff;
             if (!diff.trim()) {
               if (await allPatchFilesUserOwned(patch)) {
                 try {
@@ -25570,6 +26176,32 @@ CLI Version: ${options.cliVersion}`;
         }
         return { conflictResolved, conflictAbsorbed, contentRefreshed };
       }
+      /**
+       * After applyPatches(), surface a warning for each (patch × file) where
+       * diff3 silently dropped lines that were unchanged context in the
+       * customer's THEIRS. The deletion stays on disk (correct diff3 outcome),
+       * but the customer must learn so they can re-add the lines if they
+       * relied on them. This is the "surface or preserve, never silently drop"
+       * contract for legitimate-deletion cases.
+       */
+      recordDroppedContextLineWarnings(results) {
+        const PREVIEW_COUNT = 5;
+        for (const result of results) {
+          if (!result.fileResults) continue;
+          for (const fr of result.fileResults) {
+            const dropped = fr.droppedContextLines;
+            if (!dropped || dropped.length === 0) continue;
+            const preview = dropped.slice(0, PREVIEW_COUNT).map((line) => `    ${line}`).join("\n");
+            const more = dropped.length > PREVIEW_COUNT ? `
+    ... and ${dropped.length - PREVIEW_COUNT} more` : "";
+            this.warnings.push(
+              `${fr.file}: ${dropped.length} line(s) that appeared as unchanged context in your customization were deleted by the new generator output. The merge followed the deletion. First lines deleted:
+${preview}${more}
+If you want to keep these lines, restore them in a follow-up commit and re-run replay; otherwise this warning can be safely ignored.`
+            );
+          }
+        }
+      }
       /**
        * After applyPatches(), strip conflict markers from conflicting files
        * so only clean content is committed. Keeps the Generated (OURS) side.
@@ -25627,6 +26259,9 @@ CLI Version: ${options.cliVersion}`;
           };
         }).filter((d) => d.files.length > 0);
         const partialCount = conflictDetails.filter((d) => d.cleanFiles && d.cleanFiles.length > 0).length;
+        const unresolvedResults = results.filter(
+          (r2) => r2.status === "conflict" || r2.patch.status === "unresolved"
+        );
         return {
           flow,
           patchesDetected: patches.length,
@@ -25643,7 +26278,7 @@ CLI Version: ${options.cliVersion}`;
           patchesRefreshed: preRebaseCounts && preRebaseCounts.contentRefreshed > 0 ? preRebaseCounts.contentRefreshed : void 0,
           conflicts: conflictResults.flatMap((r2) => r2.fileResults?.filter((f2) => f2.status === "conflict") ?? []),
           conflictDetails: conflictDetails.length > 0 ? conflictDetails : void 0,
-          unresolvedPatches: conflictResults.length > 0 ? conflictResults.map((r2) => ({
+          unresolvedPatches: unresolvedResults.length > 0 ? unresolvedResults.map((r2) => ({
             patchId: r2.patch.id,
             patchMessage: r2.patch.original_message,
             files: r2.patch.files,
@@ -25664,10 +26299,10 @@ CLI Version: ${options.cliVersion}`;
         this.outputDir = outputDir;
       }
       fernignoreExists() {
-        return (0, import_fs8.existsSync)((0, import_path10.join)(this.outputDir, ".fernignore"));
+        return (0, import_fs8.existsSync)((0, import_path11.join)(this.outputDir, ".fernignore"));
       }
       readFernignorePatterns() {
-        const fernignorePath = (0, import_path10.join)(this.outputDir, ".fernignore");
+        const fernignorePath = (0, import_path11.join)(this.outputDir, ".fernignore");
         if (!(0, import_fs8.existsSync)(fernignorePath)) {
           return [];
         }
@@ -25727,7 +26362,16 @@ CLI Version: ${options.cliVersion}`;
                 original_author: "Fern Replay <replay@buildwithfern.com>",
                 base_generation: currentGen.commit_sha,
                 files: patchFiles,
-                patch_content: patchContent
+                patch_content: patchContent,
+                // Synthetic patches captured from .fernignore-protected files
+                // are user-owned by definition — the customer's content
+                // diverges from the generator's pristine output, and the
+                // generator never produced this divergent content. Without
+                // this flag, removing the file from .fernignore later (so
+                // it leaves the protection check in `isFileUserOwned`) would
+                // expose the patch to absorption on the next regen,
+                // silently losing the customization.
+                user_owned: true
               });
               trackedByBoth.push({
                 file: pattern,
@@ -25760,7 +26404,7 @@ CLI Version: ${options.cliVersion}`;
         return results;
       }
       readFileContent(filePath) {
-        const fullPath = (0, import_path10.join)(this.outputDir, filePath);
+        const fullPath = (0, import_path11.join)(this.outputDir, filePath);
         if (!(0, import_fs8.existsSync)(fullPath)) {
           return null;
         }
@@ -25825,7 +26469,7 @@ CLI Version: ${options.cliVersion}`;
         };
       }
       movePatternsToReplayYml(patterns) {
-        const replayYmlPath = (0, import_path10.join)(this.outputDir, ".fern", "replay.yml");
+        const replayYmlPath = (0, import_path11.join)(this.outputDir, ".fern", "replay.yml");
         let config = {};
         if ((0, import_fs8.existsSync)(replayYmlPath)) {
           const content = (0, import_fs8.readFileSync)(replayYmlPath, "utf-8");
@@ -25834,7 +26478,7 @@ CLI Version: ${options.cliVersion}`;
         const existing = config.exclude ?? [];
         const merged = [.../* @__PURE__ */ new Set([...existing, ...patterns])];
         config.exclude = merged;
-        const dir = (0, import_path10.dirname)(replayYmlPath);
+        const dir = (0, import_path11.dirname)(replayYmlPath);
         if (!(0, import_fs8.existsSync)(dir)) {
           (0, import_fs8.mkdirSync)(dir, { recursive: true });
         }
@@ -26338,7 +26982,7 @@ var require_cross_spawn = __commonJS({
     var cp2 = require("child_process");
     var parse3 = require_parse2();
     var enoent = require_enoent();
-    function spawn2(command, args, options) {
+    function spawn3(command, args, options) {
       const parsed = parse3(command, args, options);
       const spawned = cp2.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
@@ -26350,8 +26994,8 @@ var require_cross_spawn = __commonJS({
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
-    module2.exports = spawn2;
-    module2.exports.spawn = spawn2;
+    module2.exports = spawn3;
+    module2.exports.spawn = spawn3;
     module2.exports.sync = spawnSync;
     module2.exports._parse = parse3;
     module2.exports._enoent = enoent;
@@ -28390,8 +29034,8 @@ function resolve(...paths) {
 
 // src/cli.ts
 var import_fs15 = __toESM(require("fs"));
-var import_promises11 = require("fs/promises");
-var import_path18 = __toESM(require("path"));
+var import_promises13 = require("fs/promises");
+var import_path20 = __toESM(require("path"));
 
 // ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/yerror.js
 var YError = class _YError extends Error {
@@ -38092,42 +38736,42 @@ function replayForget(params) {
 // src/replay/replay-init.ts
 init_dist3();
 var import_fs11 = require("fs");
-var import_path13 = require("path");
+var import_path15 = require("path");
 var import_tmp_promise2 = __toESM(require_tmp_promise());
 
 // src/replay/fernignore.ts
-var import_promises4 = require("fs/promises");
-var import_path12 = require("path");
+var import_promises6 = require("fs/promises");
+var import_path14 = 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_path12.join)(outputDir, ".fernignore");
+  const fernignorePath = (0, import_path14.join)(outputDir, ".fernignore");
   let content = "";
   try {
-    content = await (0, import_promises4.readFile)(fernignorePath, "utf-8");
+    content = await (0, import_promises6.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_promises4.writeFile)(fernignorePath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
+    await (0, import_promises6.writeFile)(fernignorePath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
     return true;
   }
   return false;
 }
 async function ensureGitattributesEntries2(outputDir) {
-  const gitattributesPath = (0, import_path12.join)(outputDir, ".gitattributes");
+  const gitattributesPath = (0, import_path14.join)(outputDir, ".gitattributes");
   let content = "";
   try {
-    content = await (0, import_promises4.readFile)(gitattributesPath, "utf-8");
+    content = await (0, import_promises6.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_promises4.writeFile)(gitattributesPath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
+    await (0, import_promises6.writeFile)(gitattributesPath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
   }
 }
 
@@ -38154,7 +38798,7 @@ async function replayInit(params) {
   if (dryRun) {
     return { bootstrap: bootstrapResult, fernignoreEntries: [], gitattributesEntries: [] };
   }
-  const lockfilePath = (0, import_path13.join)(repoPath, ".fern", "replay.lock");
+  const lockfilePath = (0, import_path15.join)(repoPath, ".fern", "replay.lock");
   const lockfileContent = (0, import_fs11.existsSync)(lockfilePath) ? (0, import_fs11.readFileSync)(lockfilePath, "utf-8") : void 0;
   return {
     bootstrap: bootstrapResult,
@@ -38275,9 +38919,9 @@ init_dist3();
 
 // src/replay/replay-run.ts
 init_dist3();
-var import_child_process3 = require("child_process");
+var import_child_process4 = require("child_process");
 var import_fs12 = require("fs");
-var import_path14 = require("path");
+var import_path16 = require("path");
 async function replayPrepare(params) {
   const {
     outputDir,
@@ -38288,7 +38932,7 @@ async function replayPrepare(params) {
     skipApplication,
     logger
   } = params;
-  const lockfilePath = (0, import_path14.join)(outputDir, ".fern", "replay.lock");
+  const lockfilePath = (0, import_path16.join)(outputDir, ".fern", "replay.lock");
   if (!(0, import_fs12.existsSync)(lockfilePath)) {
     return null;
   }
@@ -38420,7 +39064,7 @@ async function replayRun(params) {
 }
 function isTagMergedIntoHead(cwd2, tagSha) {
   try {
-    (0, import_child_process3.execFileSync)("git", ["merge-base", "--is-ancestor", tagSha, "HEAD"], {
+    (0, import_child_process4.execFileSync)("git", ["merge-base", "--is-ancestor", tagSha, "HEAD"], {
       cwd: cwd2,
       stdio: "pipe"
     });
@@ -38432,7 +39076,7 @@ function isTagMergedIntoHead(cwd2, tagSha) {
     return false;
   }
   try {
-    const trees = (0, import_child_process3.execFileSync)("git", ["log", "HEAD", "--format=%T", "--max-count=500"], {
+    const trees = (0, import_child_process4.execFileSync)("git", ["log", "HEAD", "--format=%T", "--max-count=500"], {
       cwd: cwd2,
       encoding: "utf-8",
       stdio: "pipe"
@@ -38444,7 +39088,7 @@ function isTagMergedIntoHead(cwd2, tagSha) {
 }
 function gitRevParse(cwd2, rev) {
   try {
-    return (0, import_child_process3.execFileSync)("git", ["rev-parse", "--verify", rev], {
+    return (0, import_child_process4.execFileSync)("git", ["rev-parse", "--verify", rev], {
       cwd: cwd2,
       encoding: "utf-8",
       stdio: "pipe"
@@ -38455,7 +39099,7 @@ function gitRevParse(cwd2, rev) {
 }
 function gitDiffNameOnly(cwd2, from, to) {
   try {
-    const output = (0, import_child_process3.execFileSync)("git", ["diff", "--name-only", from, to], {
+    const output = (0, import_child_process4.execFileSync)("git", ["diff", "--name-only", from, to], {
       cwd: cwd2,
       encoding: "utf-8",
       stdio: "pipe"
@@ -38473,29 +39117,29 @@ function replayStatus(params) {
 }
 
 // src/configuration/loadGitHubConfig.ts
-var import_promises5 = require("fs/promises");
+var import_promises7 = require("fs/promises");
 async function loadGitHubConfig({
   absolutePathToConfig
 }) {
-  const rawContents = await (0, import_promises5.readFile)(absolutePathToConfig, "utf8");
+  const rawContents = await (0, import_promises7.readFile)(absolutePathToConfig, "utf8");
   return JSON.parse(rawContents);
 }
 
 // src/configuration/loadReadmeConfig.ts
-var import_promises6 = require("fs/promises");
+var import_promises8 = require("fs/promises");
 async function loadReadmeConfig({
   absolutePathToConfig
 }) {
-  const rawContents = await (0, import_promises6.readFile)(absolutePathToConfig, "utf8");
+  const rawContents = await (0, import_promises8.readFile)(absolutePathToConfig, "utf8");
   return JSON.parse(rawContents);
 }
 
 // src/configuration/loadReferenceConfig.ts
-var import_promises7 = require("fs/promises");
+var import_promises9 = require("fs/promises");
 async function loadReferenceConfig({
   absolutePathToConfig
 }) {
-  const rawContents = await (0, import_promises7.readFile)(absolutePathToConfig, "utf8");
+  const rawContents = await (0, import_promises9.readFile)(absolutePathToConfig, "utf8");
   return JSON.parse(rawContents);
 }
 
@@ -38512,7 +39156,7 @@ var consolePipelineLogger = {
 };
 
 // src/pipeline/PostGenerationPipeline.ts
-var import_child_process5 = require("child_process");
+var import_child_process6 = require("child_process");
 
 // src/pipeline/github/constants.ts
 var FERN_BOT_NAME2 = "fern-api";
@@ -38520,10 +39164,10 @@ var FERN_BOT_EMAIL2 = "115122769+fern-api[bot]@users.noreply.github.com";
 var FERN_BOT_LOGIN2 = "fern-api[bot]";
 
 // src/pipeline/steps/AutoVersionStep.ts
-var import_child_process4 = require("child_process");
+var import_child_process5 = require("child_process");
 var import_fs14 = require("fs");
-var import_promises9 = require("fs/promises");
-var import_path16 = require("path");
+var import_promises11 = require("fs/promises");
+var import_path18 = require("path");
 
 // ../commons/logging-execa/lib/loggingExeca.js
 var import_execa = __toESM(require_execa(), 1);
@@ -38582,8 +39226,8 @@ async function loggingExeca(logger, executable, args = [], { doNotPipeOutput = f
 
 // src/autoversion/AutoVersioningService.ts
 var import_fs13 = require("fs");
-var import_promises8 = require("fs/promises");
-var import_path15 = require("path");
+var import_promises10 = require("fs/promises");
+var import_path17 = require("path");
 var import_semver = __toESM(require_semver2());
 var AutoVersioningException = class extends Error {
   /**
@@ -39270,7 +39914,7 @@ var AutoVersioningService = class _AutoVersioningService {
       );
       return;
     }
-    const goModPath = (0, import_path15.join)(workingDirectory, "go.mod");
+    const goModPath = (0, import_path17.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;
@@ -39304,7 +39948,7 @@ var AutoVersioningService = class _AutoVersioningService {
    * Reads the module path from a go.mod file.
    */
   async readGoModulePath(goModPath) {
-    const content = await (0, import_promises8.readFile)(goModPath, "utf-8");
+    const content = await (0, import_promises10.readFile)(goModPath, "utf-8");
     for (const line of content.split("\n")) {
       const trimmed2 = line.trim();
       if (trimmed2.startsWith("module ")) {
@@ -39317,7 +39961,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_promises8.readFile)(goModPath, "utf-8");
+    const content = await (0, import_promises10.readFile)(goModPath, "utf-8");
     const lines = content.split("\n");
     let changed = false;
     for (let i = 0; i < lines.length; i++) {
@@ -39329,7 +39973,7 @@ var AutoVersioningService = class _AutoVersioningService {
       }
     }
     if (changed) {
-      await (0, import_promises8.writeFile)(goModPath, lines.join("\n"), "utf-8");
+      await (0, import_promises10.writeFile)(goModPath, lines.join("\n"), "utf-8");
       this.logger.debug(`Updated go.mod: added ${suffix} to module path`);
     }
   }
@@ -39338,10 +39982,10 @@ var AutoVersioningService = class _AutoVersioningService {
    */
   async walkDirectory(dir, filter2) {
     const results = [];
-    const entries2 = await (0, import_promises8.readdir)(dir);
+    const entries2 = await (0, import_promises10.readdir)(dir);
     for (const entry of entries2) {
-      const fullPath = (0, import_path15.join)(dir, entry);
-      const entryStat = await (0, import_promises8.stat)(fullPath);
+      const fullPath = (0, import_path17.join)(dir, entry);
+      const entryStat = await (0, import_promises10.stat)(fullPath);
       if (entryStat.isDirectory()) {
         if (entry === ".git" || entry === "vendor") {
           continue;
@@ -39358,7 +40002,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_path15.extname)(filePath) === ".go");
+    const goFiles = await this.walkDirectory(repoRoot, (filePath) => (0, import_path17.extname)(filePath) === ".go");
     for (const filePath of goFiles) {
       await this.addSuffixToGoFile(filePath, modulePath, suffix);
     }
@@ -39368,7 +40012,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_promises8.readFile)(filePath, "utf-8");
+    const content = await (0, import_promises10.readFile)(filePath, "utf-8");
     const lines = content.split("\n");
     let changed = false;
     let inImportBlock = false;
@@ -39397,7 +40041,7 @@ var AutoVersioningService = class _AutoVersioningService {
       }
     }
     if (changed) {
-      await (0, import_promises8.writeFile)(filePath, lines.join("\n"), "utf-8");
+      await (0, import_promises10.writeFile)(filePath, lines.join("\n"), "utf-8");
       this.logger.debug(`Updated Go imports in ${filePath}`);
     }
   }
@@ -39760,7 +40404,7 @@ var AutoVersionStep = class extends BaseStep {
   }
   async readVersionFromMetadata() {
     try {
-      const output = (0, import_child_process4.execFileSync)("git", ["show", "HEAD~1:.fern/metadata.json"], {
+      const output = (0, import_child_process5.execFileSync)("git", ["show", "HEAD~1:.fern/metadata.json"], {
         cwd: this.outputDir,
         encoding: "utf-8",
         stdio: "pipe"
@@ -39776,7 +40420,7 @@ var AutoVersionStep = class extends BaseStep {
     return mappedMagicVersion.startsWith("v") ? `v${stripped}` : stripped;
   }
   gitDiff(from, to) {
-    return (0, import_child_process4.execFileSync)("git", ["diff", from, to, "--", ".", ":(exclude).fern/metadata.json"], {
+    return (0, import_child_process5.execFileSync)("git", ["diff", from, to, "--", ".", ":(exclude).fern/metadata.json"], {
       cwd: this.outputDir,
       encoding: "utf-8",
       stdio: "pipe",
@@ -39789,12 +40433,12 @@ var AutoVersionStep = class extends BaseStep {
     const fullMessage = body.length > 0 ? `${COMMIT_MARKER} ${subject}
 
 ${body}` : `${COMMIT_MARKER} ${subject}`;
-    (0, import_child_process4.execFileSync)("git", ["add", "-A"], { cwd: this.outputDir, stdio: "pipe" });
-    (0, import_child_process4.execFileSync)("git", ["commit", "--allow-empty", "-m", fullMessage], {
+    (0, import_child_process5.execFileSync)("git", ["add", "-A"], { cwd: this.outputDir, stdio: "pipe" });
+    (0, import_child_process5.execFileSync)("git", ["commit", "--allow-empty", "-m", fullMessage], {
       cwd: this.outputDir,
       stdio: "pipe"
     });
-    return (0, import_child_process4.execFileSync)("git", ["rev-parse", "HEAD"], {
+    return (0, import_child_process5.execFileSync)("git", ["rev-parse", "HEAD"], {
       cwd: this.outputDir,
       encoding: "utf-8",
       stdio: "pipe"
@@ -39802,7 +40446,7 @@ ${body}` : `${COMMIT_MARKER} ${subject}`;
   }
   async prependChangelogEntry(params) {
     const { version: version2, entry } = params;
-    const changelogPath = (0, import_path16.join)(this.outputDir, "changelog.md");
+    const changelogPath = (0, import_path18.join)(this.outputDir, "changelog.md");
     const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const header = `## [${version2}] - ${now}
 `;
@@ -39811,7 +40455,7 @@ ${body}` : `${COMMIT_MARKER} ${subject}`;
 `;
     let existing = "";
     if ((0, import_fs14.existsSync)(changelogPath)) {
-      existing = await (0, import_promises9.readFile)(changelogPath, "utf-8");
+      existing = await (0, import_promises11.readFile)(changelogPath, "utf-8");
     }
     let output;
     if (existing.trim().length === 0) {
@@ -39828,7 +40472,7 @@ ${newBlock}${remainder}`;
     } else {
       output = `${newBlock}${existing}`;
     }
-    await (0, import_promises9.writeFile)(changelogPath, output, "utf-8");
+    await (0, import_promises11.writeFile)(changelogPath, output, "utf-8");
   }
   brandMessage(message) {
     if (this.config.isWhitelabel) {
@@ -40010,8 +40654,8 @@ var GenerationCommitStep = class extends BaseStep {
 };
 
 // src/pipeline/steps/GithubStep.ts
-var import_promises10 = require("fs/promises");
-var import_path17 = require("path");
+var import_promises12 = require("fs/promises");
+var import_path19 = require("path");
 
 // src/pipeline/github/createReplayBranch.ts
 async function createReplayBranch(repository, branchName, commitMessage, replayConflictInfo, logger) {
@@ -40628,13 +41272,13 @@ var GithubStep = class extends BaseStep {
   }
   async ensureFernignore() {
     this.logger.debug("Checking for .fernignore file...");
-    const fernignorePath = (0, import_path17.join)(this.outputDir, ".fernignore");
+    const fernignorePath = (0, import_path19.join)(this.outputDir, ".fernignore");
     try {
-      await (0, import_promises10.access)(fernignorePath);
+      await (0, import_promises12.access)(fernignorePath);
       this.logger.debug(".fernignore already exists");
     } catch {
       this.logger.debug("Creating .fernignore file...");
-      await (0, import_promises10.writeFile)(fernignorePath, "# Specify files that shouldn't be modified by Fern\n", "utf-8");
+      await (0, import_promises12.writeFile)(fernignorePath, "# Specify files that shouldn't be modified by Fern\n", "utf-8");
     }
   }
   deriveSkipCommit(replayResult) {
@@ -40856,8 +41500,8 @@ var PostGenerationPipeline = class {
   async run() {
     if (this.config.github?.enabled) {
       try {
-        (0, import_child_process5.execFileSync)("git", ["config", "user.name", FERN_BOT_NAME2], { cwd: this.config.outputDir });
-        (0, import_child_process5.execFileSync)("git", ["config", "user.email", FERN_BOT_EMAIL2], { cwd: this.config.outputDir });
+        (0, import_child_process6.execFileSync)("git", ["config", "user.name", FERN_BOT_NAME2], { cwd: this.config.outputDir });
+        (0, import_child_process6.execFileSync)("git", ["config", "user.email", FERN_BOT_EMAIL2], { cwd: this.config.outputDir });
       } catch {
       }
     }
@@ -40927,7 +41571,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_promises11.readFile)(argv.originalReadme, "utf8") : void 0;
+    const originalReadmeContent = argv.originalReadme != null ? await (0, import_promises13.readFile)(argv.originalReadme, "utf8") : void 0;
     await generateReadmeToStream({
       originalReadmeContent,
       readmeConfig,
@@ -41055,7 +41699,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_promises11.readFile)(resolve(wd, configValue), "utf-8");
+        const configContent = configValue === STDIN_MARKER ? await readStdin() : configValue.trimStart().startsWith("{") ? configValue : await (0, import_promises13.readFile)(resolve(wd, configValue), "utf-8");
         let config;
         try {
           config = JSON.parse(configContent);
@@ -41351,7 +41995,7 @@ async function createWriteStream(outputPath) {
 }
 async function createWriteStreamFromFile(filepath) {
   if (!await doesPathExist(filepath)) {
-    await (0, import_promises11.mkdir)(import_path18.default.dirname(filepath), { recursive: true });
+    await (0, import_promises13.mkdir)(import_path20.default.dirname(filepath), { recursive: true });
   }
   return import_fs15.default.createWriteStream(filepath);
 }