@fern-api/replay 0.9.0 → 0.10.0

package/dist/index.js

@@ -111,6 +111,14 @@ var init_GitClient = __esm({
           return false;
         }
       }
+      async treeExists(treeHash) {
+        try {
+          const type = await this.exec(["cat-file", "-t", treeHash]);
+          return type.trim() === "tree";
+        } catch {
+          return false;
+        }
+      }
       async getCommitBody(commitSha) {
         return this.exec(["log", "-1", "--format=%B", commitSha]);
       }
@@ -121,6 +129,255 @@ var init_GitClient = __esm({
   }
 });
 
+// src/HybridReconstruction.ts
+var HybridReconstruction_exports = {};
+__export(HybridReconstruction_exports, {
+  assembleHybrid: () => assembleHybrid,
+  locateHunksInOurs: () => locateHunksInOurs,
+  parseHunks: () => parseHunks,
+  reconstructFromGhostPatch: () => reconstructFromGhostPatch
+});
+function parseHunks(fileDiff) {
+  const lines = fileDiff.split("\n");
+  const hunks = [];
+  let currentHunk = null;
+  for (const line of lines) {
+    const headerMatch = line.match(
+      /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/
+    );
+    if (headerMatch) {
+      if (currentHunk) {
+        hunks.push(currentHunk);
+      }
+      currentHunk = {
+        oldStart: parseInt(headerMatch[1], 10),
+        oldCount: headerMatch[2] != null ? parseInt(headerMatch[2], 10) : 1,
+        newStart: parseInt(headerMatch[3], 10),
+        newCount: headerMatch[4] != null ? parseInt(headerMatch[4], 10) : 1,
+        lines: []
+      };
+      continue;
+    }
+    if (!currentHunk) continue;
+    if (line.startsWith("diff --git") || line.startsWith("index ") || line.startsWith("---") || line.startsWith("+++") || line.startsWith("old mode") || line.startsWith("new mode") || line.startsWith("similarity index") || line.startsWith("rename from") || line.startsWith("rename to") || line.startsWith("new file mode") || line.startsWith("deleted file mode")) {
+      continue;
+    }
+    if (line === "\") {
+      continue;
+    }
+    if (line.startsWith("-")) {
+      currentHunk.lines.push({ type: "remove", content: line.slice(1) });
+    } else if (line.startsWith("+")) {
+      currentHunk.lines.push({ type: "add", content: line.slice(1) });
+    } else if (line.startsWith(" ") || line === "") {
+      currentHunk.lines.push({
+        type: "context",
+        content: line.startsWith(" ") ? line.slice(1) : line
+      });
+    }
+  }
+  if (currentHunk) {
+    hunks.push(currentHunk);
+  }
+  return hunks;
+}
+function extractLeadingContext(hunk) {
+  const result = [];
+  for (const line of hunk.lines) {
+    if (line.type !== "context") break;
+    result.push(line.content);
+  }
+  return result;
+}
+function extractTrailingContext(hunk) {
+  const result = [];
+  for (let i = hunk.lines.length - 1; i >= 0; i--) {
+    if (hunk.lines[i].type !== "context") break;
+    result.unshift(hunk.lines[i].content);
+  }
+  return result;
+}
+function countOursLinesBeforeTrailing(hunk) {
+  let count = 0;
+  const trailingStart = findTrailingContextStart(hunk);
+  for (let i = 0; i < trailingStart; i++) {
+    if (hunk.lines[i].type === "context") count++;
+  }
+  return count;
+}
+function findTrailingContextStart(hunk) {
+  let i = hunk.lines.length - 1;
+  while (i >= 0 && hunk.lines[i].type === "context") {
+    i--;
+  }
+  return i + 1;
+}
+function matchesAt(needle, haystack, offset) {
+  for (let i = 0; i < needle.length; i++) {
+    if (haystack[offset + i] !== needle[i]) return false;
+  }
+  return true;
+}
+function findContextInOurs(contextLines, oursLines, minIndex, hint) {
+  const SEARCH_WINDOW = 200;
+  const maxStart = oursLines.length - contextLines.length;
+  const clampedHint = Math.max(minIndex, Math.min(hint, maxStart));
+  if (clampedHint >= minIndex && clampedHint <= maxStart) {
+    if (matchesAt(contextLines, oursLines, clampedHint)) {
+      return clampedHint;
+    }
+  }
+  for (let delta = 1; delta <= SEARCH_WINDOW; delta++) {
+    for (const sign of [1, -1]) {
+      const idx = clampedHint + delta * sign;
+      if (idx < minIndex || idx > maxStart) continue;
+      if (matchesAt(contextLines, oursLines, idx)) {
+        return idx;
+      }
+    }
+  }
+  return -1;
+}
+function computeOursSpan(hunk, oursLines, oursOffset) {
+  const leading = extractLeadingContext(hunk);
+  const trailing = extractTrailingContext(hunk);
+  if (trailing.length === 0) {
+    const contextCount2 = hunk.lines.filter(
+      (l) => l.type === "context"
+    ).length;
+    return Math.min(contextCount2, oursLines.length - oursOffset);
+  }
+  const searchStart = oursOffset + leading.length;
+  for (let i = searchStart; i <= oursLines.length - trailing.length; i++) {
+    if (matchesAt(trailing, oursLines, i)) {
+      return i + trailing.length - oursOffset;
+    }
+  }
+  const contextCount = hunk.lines.filter(
+    (l) => l.type === "context"
+  ).length;
+  return Math.min(contextCount, oursLines.length - oursOffset);
+}
+function locateHunksInOurs(hunks, oursLines) {
+  const located = [];
+  let minOursIndex = 0;
+  for (const hunk of hunks) {
+    const contextLines = extractLeadingContext(hunk);
+    let oursOffset;
+    if (contextLines.length > 0) {
+      const found = findContextInOurs(
+        contextLines,
+        oursLines,
+        minOursIndex,
+        hunk.newStart - 1
+      );
+      if (found === -1) {
+        const trailingContext = extractTrailingContext(hunk);
+        if (trailingContext.length > 0) {
+          const trailingFound = findContextInOurs(
+            trailingContext,
+            oursLines,
+            minOursIndex,
+            hunk.newStart - 1
+          );
+          if (trailingFound === -1) return null;
+          const nonTrailingCount = countOursLinesBeforeTrailing(hunk);
+          oursOffset = trailingFound - nonTrailingCount;
+          if (oursOffset < minOursIndex) return null;
+        } else {
+          return null;
+        }
+      } else {
+        oursOffset = found;
+      }
+    } else if (hunk.oldStart === 1 && hunk.oldCount === 0) {
+      oursOffset = 0;
+    } else {
+      oursOffset = Math.max(hunk.newStart - 1, minOursIndex);
+    }
+    const oursSpan = computeOursSpan(hunk, oursLines, oursOffset);
+    located.push({ hunk, oursOffset, oursSpan });
+    minOursIndex = oursOffset + oursSpan;
+  }
+  return located;
+}
+function assembleHybrid(locatedHunks, oursLines) {
+  const baseLines = [];
+  const theirsLines = [];
+  let oursCursor = 0;
+  for (const { hunk, oursOffset, oursSpan } of locatedHunks) {
+    if (oursOffset > oursCursor) {
+      const gapLines = oursLines.slice(oursCursor, oursOffset);
+      baseLines.push(...gapLines);
+      theirsLines.push(...gapLines);
+    }
+    for (const line of hunk.lines) {
+      switch (line.type) {
+        case "context":
+          baseLines.push(line.content);
+          theirsLines.push(line.content);
+          break;
+        case "remove":
+          baseLines.push(line.content);
+          break;
+        case "add":
+          theirsLines.push(line.content);
+          break;
+      }
+    }
+    oursCursor = oursOffset + oursSpan;
+  }
+  if (oursCursor < oursLines.length) {
+    const gapLines = oursLines.slice(oursCursor);
+    baseLines.push(...gapLines);
+    theirsLines.push(...gapLines);
+  }
+  return {
+    base: baseLines.join("\n"),
+    theirs: theirsLines.join("\n")
+  };
+}
+function reconstructFromGhostPatch(fileDiff, ours) {
+  const hunks = parseHunks(fileDiff);
+  if (hunks.length === 0) {
+    return null;
+  }
+  const isPureAddition = hunks.every(
+    (h) => h.oldCount === 0 && h.lines.every((l) => l.type !== "remove")
+  );
+  if (isPureAddition) {
+    return null;
+  }
+  const isPureDeletion = hunks.every(
+    (h) => h.newCount === 0 && h.lines.every((l) => l.type !== "add")
+  );
+  if (isPureDeletion) {
+    const baseLines = [];
+    for (const hunk of hunks) {
+      for (const line of hunk.lines) {
+        if (line.type === "context" || line.type === "remove") {
+          baseLines.push(line.content);
+        }
+      }
+    }
+    return {
+      base: baseLines.join("\n"),
+      theirs: ""
+    };
+  }
+  const oursLines = ours.split("\n");
+  const located = locateHunksInOurs(hunks, oursLines);
+  if (!located) {
+    return null;
+  }
+  return assembleHybrid(located, oursLines);
+}
+var init_HybridReconstruction = __esm({
+  "src/HybridReconstruction.ts"() {
+    "use strict";
+  }
+});
+
 // src/index.ts
 init_GitClient();
 
@@ -158,6 +415,12 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from "
 import { join, dirname } from "path";
 import { stringify, parse } from "yaml";
 var LOCKFILE_HEADER = "# DO NOT EDIT MANUALLY - Managed by Fern Replay\n";
+var LockfileNotFoundError = class extends Error {
+  constructor(path) {
+    super(`Lockfile not found: ${path}`);
+    this.name = "LockfileNotFoundError";
+  }
+};
 var LockfileManager = class {
   outputDir;
   lock = null;
@@ -177,12 +440,16 @@ var LockfileManager = class {
     if (this.lock) {
       return this.lock;
     }
-    if (!this.exists()) {
-      throw new Error(`Lockfile not found: ${this.lockfilePath}`);
+    try {
+      const content = readFileSync(this.lockfilePath, "utf-8");
+      this.lock = parse(content);
+      return this.lock;
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        throw new LockfileNotFoundError(this.lockfilePath);
+      }
+      throw error;
     }
-    const content = readFileSync(this.lockfilePath, "utf-8");
-    this.lock = parse(content);
-    return this.lock;
   }
   initialize(firstGeneration) {
     this.initializeInMemory(firstGeneration);
@@ -328,13 +595,21 @@ var ReplayDetector = class {
     const exists = await this.git.commitExists(lastGen.commit_sha);
     if (!exists) {
       this.warnings.push(
-        `Generation commit ${lastGen.commit_sha.slice(0, 7)} not found in git history. Skipping new patch detection. Existing lockfile patches will still be applied.`
+        `Generation commit ${lastGen.commit_sha.slice(0, 7)} not found in git history. Falling back to alternate detection.`
+      );
+      return this.detectPatchesViaTreeDiff(
+        lastGen,
+        /* commitKnownMissing */
+        true
       );
-      return { patches: [], revertedPatchIds: [] };
     }
     const isAncestor = await this.git.isAncestor(lastGen.commit_sha, "HEAD");
     if (!isAncestor) {
-      return this.detectPatchesViaTreeDiff(lastGen);
+      return this.detectPatchesViaTreeDiff(
+        lastGen,
+        /* commitKnownMissing */
+        false
+      );
     }
     const log = await this.git.exec([
       "log",
@@ -360,7 +635,15 @@ var ReplayDetector = class {
       if (lock.patches.find((p) => p.original_commit === commit.sha)) {
         continue;
       }
-      const patchContent = await this.git.formatPatch(commit.sha);
+      let patchContent;
+      try {
+        patchContent = await this.git.formatPatch(commit.sha);
+      } catch {
+        this.warnings.push(
+          `Could not generate patch for commit ${commit.sha.slice(0, 7)} \u2014 it may be unreachable in a shallow clone. Skipping.`
+        );
+        continue;
+      }
       const contentHash = this.computeContentHash(patchContent);
       if (lock.patches.find((p) => p.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
         continue;
@@ -453,11 +736,15 @@ var ReplayDetector = class {
    * Revert reconciliation is skipped here because tree-diff produces a single composite
    * patch from the aggregate diff — individual revert commits are not distinguishable.
    */
-  async detectPatchesViaTreeDiff(lastGen) {
-    const filesOutput = await this.git.exec(["diff", "--name-only", lastGen.commit_sha, "HEAD"]);
+  async detectPatchesViaTreeDiff(lastGen, commitKnownMissing) {
+    const diffBase = await this.resolveDiffBase(lastGen, commitKnownMissing);
+    if (!diffBase) {
+      return this.detectPatchesViaCommitScan();
+    }
+    const filesOutput = await this.git.exec(["diff", "--name-only", diffBase, "HEAD"]);
     const files = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
     if (files.length === 0) return { patches: [], revertedPatchIds: [] };
-    const diff = await this.git.exec(["diff", lastGen.commit_sha, "HEAD", "--", ...files]);
+    const diff = await this.git.exec(["diff", diffBase, "HEAD", "--", ...files]);
     if (!diff.trim()) return { patches: [], revertedPatchIds: [] };
     const contentHash = this.computeContentHash(diff);
     const lock = this.lockManager.read();
@@ -471,12 +758,113 @@ var ReplayDetector = class {
       original_commit: headSha,
       original_message: "Customer customizations (composite)",
       original_author: "composite",
-      base_generation: lastGen.commit_sha,
+      // Use diffBase when commit is unreachable — the applicator needs a reachable
+      // reference to find base file content. diffBase may be the tree_hash.
+      base_generation: commitKnownMissing ? diffBase : lastGen.commit_sha,
       files,
       patch_content: diff
     };
     return { patches: [compositePatch], revertedPatchIds: [] };
   }
+  /**
+   * Last-resort detection when both generation commit and tree are unreachable.
+   * Scans all commits from HEAD, filters against known lockfile patches, and
+   * skips creation-only commits (squashed history after force push).
+   *
+   * Detected patches use the commit's parent as base_generation so the applicator
+   * can find base file content from the parent's tree (which IS reachable).
+   */
+  async detectPatchesViaCommitScan() {
+    const lock = this.lockManager.read();
+    const log = await this.git.exec([
+      "log",
+      "--max-count=200",
+      "--format=%H%x00%an%x00%ae%x00%s",
+      "HEAD",
+      "--",
+      this.sdkOutputDir
+    ]);
+    if (!log.trim()) {
+      return { patches: [], revertedPatchIds: [] };
+    }
+    const commits = this.parseGitLog(log);
+    const newPatches = [];
+    const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
+    const existingHashes = new Set(lock.patches.map((p) => p.content_hash));
+    const existingCommits = new Set(lock.patches.map((p) => p.original_commit));
+    for (const commit of commits) {
+      if (isGenerationCommit(commit)) {
+        continue;
+      }
+      const parents = await this.git.getCommitParents(commit.sha);
+      if (parents.length > 1) {
+        continue;
+      }
+      if (existingCommits.has(commit.sha)) {
+        continue;
+      }
+      let patchContent;
+      try {
+        patchContent = await this.git.formatPatch(commit.sha);
+      } catch {
+        continue;
+      }
+      const contentHash = this.computeContentHash(patchContent);
+      if (existingHashes.has(contentHash) || forgottenHashes.has(contentHash)) {
+        continue;
+      }
+      if (this.isCreationOnlyPatch(patchContent)) {
+        continue;
+      }
+      const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
+      const files = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f));
+      if (files.length === 0) {
+        continue;
+      }
+      if (parents.length === 0) {
+        continue;
+      }
+      const parentSha = parents[0];
+      newPatches.push({
+        id: `patch-${commit.sha.slice(0, 8)}`,
+        content_hash: contentHash,
+        original_commit: commit.sha,
+        original_message: commit.message,
+        original_author: `${commit.authorName} <${commit.authorEmail}>`,
+        base_generation: parentSha,
+        files,
+        patch_content: patchContent
+      });
+    }
+    newPatches.reverse();
+    return { patches: newPatches, revertedPatchIds: [] };
+  }
+  /**
+   * Check if a format-patch consists entirely of new-file creations.
+   * Used to identify squashed commits after force push, which create all files
+   * from scratch (--- /dev/null) rather than modifying existing files.
+   */
+  isCreationOnlyPatch(patchContent) {
+    const diffOldHeaders = patchContent.split("\n").filter((l) => l.startsWith("--- "));
+    if (diffOldHeaders.length === 0) {
+      return false;
+    }
+    return diffOldHeaders.every((l) => l === "--- /dev/null");
+  }
+  /**
+   * Resolve the best available diff base for a generation record.
+   * Prefers commit_sha, falls back to tree_hash for unreachable commits.
+   * When commitKnownMissing is true, skips the redundant commitExists check.
+   */
+  async resolveDiffBase(gen, commitKnownMissing) {
+    if (!commitKnownMissing && await this.git.commitExists(gen.commit_sha)) {
+      return gen.commit_sha;
+    }
+    if (await this.git.treeExists(gen.tree_hash)) {
+      return gen.tree_hash;
+    }
+    return null;
+  }
   parseGitLog(log) {
     return log.trim().split("\n").map((line) => {
       const [sha, authorName, authorEmail, message] = line.split("\0");
@@ -489,7 +877,7 @@ var ReplayDetector = class {
 };
 
 // src/ThreeWayMerge.ts
-import { diff3Merge } from "node-diff3";
+import { diff3Merge, diffPatch } from "node-diff3";
 function threeWayMerge(base, ours, theirs) {
   const baseLines = base.split("\n");
   const oursLines = ours.split("\n");
@@ -503,20 +891,33 @@ function threeWayMerge(base, ours, theirs) {
       outputLines.push(...region.ok);
       currentLine += region.ok.length;
     } else if (region.conflict) {
-      const startLine = currentLine;
-      outputLines.push("<<<<<<< Generated");
-      outputLines.push(...region.conflict.a);
-      outputLines.push("=======");
-      outputLines.push(...region.conflict.b);
-      outputLines.push(">>>>>>> Your customization");
-      const conflictLines = region.conflict.a.length + region.conflict.b.length + 3;
-      conflicts.push({
-        startLine,
-        endLine: startLine + conflictLines - 1,
-        ours: region.conflict.a,
-        theirs: region.conflict.b
-      });
-      currentLine += conflictLines;
+      const resolved = tryResolveConflict(
+        region.conflict.a,
+        // ours (generator)
+        region.conflict.o,
+        // base
+        region.conflict.b
+        // theirs (user)
+      );
+      if (resolved !== null) {
+        outputLines.push(...resolved);
+        currentLine += resolved.length;
+      } else {
+        const startLine = currentLine;
+        outputLines.push("<<<<<<< Generated");
+        outputLines.push(...region.conflict.a);
+        outputLines.push("=======");
+        outputLines.push(...region.conflict.b);
+        outputLines.push(">>>>>>> Your customization");
+        const conflictLines = region.conflict.a.length + region.conflict.b.length + 3;
+        conflicts.push({
+          startLine,
+          endLine: startLine + conflictLines - 1,
+          ours: region.conflict.a,
+          theirs: region.conflict.b
+        });
+        currentLine += conflictLines;
+      }
     }
   }
   return {
@@ -525,6 +926,62 @@ function threeWayMerge(base, ours, theirs) {
     conflicts
   };
 }
+function tryResolveConflict(oursLines, baseLines, theirsLines) {
+  if (baseLines.length === 0) {
+    return null;
+  }
+  const oursPatches = diffPatch(baseLines, oursLines);
+  const theirsPatches = diffPatch(baseLines, theirsLines);
+  if (oursPatches.length === 0) return theirsLines;
+  if (theirsPatches.length === 0) return oursLines;
+  if (patchesOverlap(oursPatches, theirsPatches)) {
+    return null;
+  }
+  return applyBothPatches(baseLines, oursPatches, theirsPatches);
+}
+function patchesOverlap(oursPatches, theirsPatches) {
+  for (const op of oursPatches) {
+    const oStart = op.buffer1.offset;
+    const oEnd = oStart + op.buffer1.length;
+    for (const tp of theirsPatches) {
+      const tStart = tp.buffer1.offset;
+      const tEnd = tStart + tp.buffer1.length;
+      if (op.buffer1.length === 0 && tp.buffer1.length === 0 && oStart === tStart) {
+        return true;
+      }
+      if (tp.buffer1.length === 0 && tStart === oEnd) {
+        return true;
+      }
+      if (op.buffer1.length === 0 && oStart === tEnd) {
+        return true;
+      }
+      if (oStart < tEnd && tStart < oEnd) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function applyBothPatches(baseLines, oursPatches, theirsPatches) {
+  const allPatches = [
+    ...oursPatches.map((p) => ({
+      offset: p.buffer1.offset,
+      length: p.buffer1.length,
+      replacement: p.buffer2.chunk
+    })),
+    ...theirsPatches.map((p) => ({
+      offset: p.buffer1.offset,
+      length: p.buffer1.length,
+      replacement: p.buffer2.chunk
+    }))
+  ];
+  allPatches.sort((a, b) => b.offset - a.offset);
+  const result = [...baseLines];
+  for (const p of allPatches) {
+    result.splice(p.offset, p.length, ...p.replacement);
+  }
+  return result;
+}
 
 // src/ReplayApplicator.ts
 import { mkdir, mkdtemp, readFile, rm, writeFile } from "fs/promises";
@@ -533,29 +990,74 @@ import { dirname as dirname2, extname, join as join2 } from "path";
 import { minimatch } from "minimatch";
 
 // src/conflict-utils.ts
+var CONFLICT_OPENER = "<<<<<<< Generated";
+var CONFLICT_SEPARATOR = "=======";
+var CONFLICT_CLOSER = ">>>>>>> Your customization";
+function trimCR(line) {
+  return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+function findConflictRanges(lines) {
+  const ranges = [];
+  let i = 0;
+  while (i < lines.length) {
+    if (trimCR(lines[i]) === CONFLICT_OPENER) {
+      let separatorIdx = -1;
+      let j = i + 1;
+      let found = false;
+      while (j < lines.length) {
+        const trimmed = trimCR(lines[j]);
+        if (trimmed === CONFLICT_OPENER) {
+          break;
+        }
+        if (separatorIdx === -1 && trimmed === CONFLICT_SEPARATOR) {
+          separatorIdx = j;
+        } else if (separatorIdx !== -1 && trimmed === CONFLICT_CLOSER) {
+          ranges.push({ start: i, separator: separatorIdx, end: j });
+          i = j;
+          found = true;
+          break;
+        }
+        j++;
+      }
+      if (!found) {
+        i++;
+        continue;
+      }
+    }
+    i++;
+  }
+  return ranges;
+}
 function stripConflictMarkers(content) {
-  const lines = content.split("\n");
+  const lines = content.split(/\r?\n/);
+  const ranges = findConflictRanges(lines);
+  if (ranges.length === 0) {
+    return content;
+  }
   const result = [];
-  let inConflict = false;
-  let inOurs = false;
-  for (const line of lines) {
-    if (line.startsWith("<<<<<<< ")) {
-      inConflict = true;
-      inOurs = true;
-      continue;
-    }
-    if (inConflict && line === "=======") {
-      inOurs = false;
-      continue;
-    }
-    if (inConflict && line.startsWith(">>>>>>> ")) {
-      inConflict = false;
-      inOurs = false;
-      continue;
-    }
-    if (!inConflict || inOurs) {
-      result.push(line);
+  let rangeIdx = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (rangeIdx < ranges.length) {
+      const range = ranges[rangeIdx];
+      if (i === range.start) {
+        continue;
+      }
+      if (i > range.start && i < range.separator) {
+        result.push(lines[i]);
+        continue;
+      }
+      if (i === range.separator) {
+        continue;
+      }
+      if (i > range.separator && i < range.end) {
+        continue;
+      }
+      if (i === range.end) {
+        rangeIdx++;
+        continue;
+      }
     }
+    result.push(lines[i]);
   }
   return result.join("\n");
 }
@@ -615,12 +1117,34 @@ var ReplayApplicator = class {
   lockManager;
   outputDir;
   renameCache = /* @__PURE__ */ new Map();
+  treeExistsCache = /* @__PURE__ */ new Map();
   fileTheirsAccumulator = /* @__PURE__ */ new Map();
   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();
@@ -702,7 +1226,7 @@ var ReplayApplicator = class {
     }
   }
   async applyPatchWithFallback(patch) {
-    const baseGen = this.lockManager.getGeneration(patch.base_generation);
+    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 ?? "";
@@ -786,7 +1310,7 @@ var ReplayApplicator = class {
   }
   async mergeFile(patch, filePath, tempGit, tempDir) {
     try {
-      const baseGen = this.lockManager.getGeneration(patch.base_generation);
+      const baseGen = await this.resolveBaseGeneration(patch.base_generation);
       if (!baseGen) {
         return { file: filePath, status: "skipped", reason: "base-generation-not-found" };
       }
@@ -811,14 +1335,44 @@ var ReplayApplicator = class {
       }
       const oursPath = join2(this.outputDir, resolvedPath);
       const ours = await readFile(oursPath, "utf-8").catch(() => null);
-      let theirs = await this.applyPatchToContent(
-        base,
-        patch.patch_content,
-        filePath,
-        tempGit,
-        tempDir,
-        renameSourcePath
-      );
+      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;
+            }
+          }
+        }
+      }
+      if (!ghostReconstructed) {
+        theirs = await this.applyPatchToContent(
+          base,
+          patch.patch_content,
+          filePath,
+          tempGit,
+          tempDir,
+          renameSourcePath
+        );
+      }
+      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"
+          };
+        }
+      }
       let useAccumulatorAsMergeBase = false;
       const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
       if (!theirs && accumulatorEntry) {
@@ -833,6 +1387,17 @@ var ReplayApplicator = class {
           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 && base && !useAccumulatorAsMergeBase) {
@@ -851,13 +1416,13 @@ var ReplayApplicator = class {
           baseMismatchSkipped = true;
         }
       }
-      if (!base && !ours && effective_theirs) {
+      if (base == null && !ours && effective_theirs) {
         const outDir2 = dirname2(oursPath);
         await mkdir(outDir2, { recursive: true });
         await writeFile(oursPath, effective_theirs);
         return { file: resolvedPath, status: "merged", reason: "new-file" };
       }
-      if (!base && ours && effective_theirs) {
+      if (base == null && ours && effective_theirs) {
         const merged2 = threeWayMerge("", ours, effective_theirs);
         const outDir2 = dirname2(oursPath);
         await mkdir(outDir2, { recursive: true });
@@ -880,7 +1445,7 @@ var ReplayApplicator = class {
           reason: "missing-content"
         };
       }
-      if (!base && !useAccumulatorAsMergeBase || !ours) {
+      if (base == null && !useAccumulatorAsMergeBase || !ours) {
         return {
           file: resolvedPath,
           status: "skipped",
@@ -899,7 +1464,7 @@ var ReplayApplicator = class {
       const outDir = dirname2(oursPath);
       await mkdir(outDir, { recursive: true });
       await writeFile(oursPath, merged.content);
-      if (effective_theirs) {
+      if (effective_theirs && !merged.hasConflicts) {
         this.fileTheirsAccumulator.set(resolvedPath, {
           content: effective_theirs,
           baseGeneration: patch.base_generation
@@ -923,6 +1488,14 @@ var ReplayApplicator = class {
       };
     }
   }
+  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;
@@ -1193,6 +1766,7 @@ var ReplayService = class {
       generator_versions: options?.generatorVersions ?? {},
       base_branch_head: options?.baseBranchHead
     };
+    let resolvedPatches;
     if (!this.lockManager.exists()) {
       this.lockManager.initializeInMemory(record);
     } else {
@@ -1201,13 +1775,13 @@ var ReplayService = class {
         ...this.lockManager.getUnresolvedPatches(),
         ...this.lockManager.getResolvingPatches()
       ];
+      resolvedPatches = this.lockManager.getPatches().filter((p) => p.status == null);
       this.lockManager.addGeneration(record);
       this.lockManager.clearPatches();
       for (const patch of unresolvedPatches) {
         this.lockManager.addPatch(patch);
       }
     }
-    this.lockManager.save();
     try {
       const { patches: redetectedPatches } = await this.detector.detectNewPatches();
       if (redetectedPatches.length > 0) {
@@ -1221,20 +1795,27 @@ var ReplayService = class {
         for (const patch of redetectedPatches) {
           this.lockManager.addPatch(patch);
         }
-        this.lockManager.save();
       }
-    } catch {
+    } 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();
   }
   determineFlow() {
-    if (!this.lockManager.exists()) {
-      return "first-generation";
-    }
-    const lock = this.lockManager.read();
-    if (lock.patches.length === 0) {
-      return "no-patches";
+    try {
+      const lock = this.lockManager.read();
+      return lock.patches.length === 0 ? "no-patches" : "normal-regeneration";
+    } catch (error) {
+      if (error instanceof LockfileNotFoundError) {
+        return "first-generation";
+      }
+      throw error;
     }
-    return "normal-regeneration";
   }
   async handleFirstGeneration(options) {
     if (options?.dryRun) {
@@ -1276,12 +1857,17 @@ var ReplayService = class {
       baseBranchHead: options.baseBranchHead
     } : void 0;
     await this.committer.commitGeneration("Update SDK (replay skipped)", commitOpts);
+    await this.cleanupStaleConflictMarkers();
     const genRecord = await this.committer.createGenerationRecord(commitOpts);
-    if (this.lockManager.exists()) {
+    try {
       this.lockManager.read();
       this.lockManager.addGeneration(genRecord);
-    } else {
-      this.lockManager.initializeInMemory(genRecord);
+    } catch (error) {
+      if (error instanceof LockfileNotFoundError) {
+        this.lockManager.initializeInMemory(genRecord);
+      } else {
+        throw error;
+      }
     }
     this.lockManager.setReplaySkippedAt((/* @__PURE__ */ new Date()).toISOString());
     this.lockManager.save();
@@ -1327,6 +1913,7 @@ var ReplayService = class {
       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);
     let results = [];
@@ -1420,6 +2007,7 @@ var ReplayService = class {
       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);
     const results = await this.applicator.applyPatches(allPatches);
@@ -1610,6 +2198,13 @@ var ReplayService = class {
             contentRefreshed++;
             continue;
           }
+          const diffLines = diff.split("\n");
+          const hasStaleMarkers = diffLines.some(
+            (l) => l.startsWith("+<<<<<<< Generated") || l.startsWith("+>>>>>>> Your customization")
+          );
+          if (hasStaleMarkers) {
+            continue;
+          }
           const newContentHash = this.detector.computeContentHash(diff);
           if (newContentHash !== patch.content_hash) {
             const filesOutput = await this.git.exec(["diff", "--name-only", currentGen, "HEAD", "--", ...patch.files]).catch(() => null);
@@ -1630,7 +2225,7 @@ var ReplayService = class {
         continue;
       }
       try {
-        const markerFiles = await this.git.exec(["grep", "-l", "<<<<<<<", "HEAD", "--", ...patch.files]).catch(() => "");
+        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;
@@ -1670,6 +2265,25 @@ var ReplayService = class {
       }
     }
   }
+  /**
+   * Clean up stale conflict markers left by a previous crashed run.
+   * Called after commitGeneration() when HEAD is the [fern-generated] commit.
+   * Restores files to their clean generated state from HEAD.
+   * Skips .fernignore-protected files to prevent overwriting user content.
+   */
+  async cleanupStaleConflictMarkers() {
+    const markerFiles = await this.git.exec(["grep", "-l", "<<<<<<< Generated", "--", "."]).catch(() => "");
+    const files = markerFiles.trim().split("\n").filter(Boolean);
+    if (files.length === 0) return;
+    const fernignorePatterns = this.readFernignorePatterns();
+    for (const file of files) {
+      if (fernignorePatterns.some((pattern) => minimatch2(file, pattern))) continue;
+      try {
+        await this.git.exec(["checkout", "HEAD", "--", file]);
+      } catch {
+      }
+    }
+  }
   readFernignorePatterns() {
     const fernignorePath = join3(this.outputDir, ".fernignore");
     if (!existsSync2(fernignorePath)) return [];
@@ -1997,6 +2611,7 @@ async function bootstrap(outputDir, options) {
   }
   lockManager.save();
   const fernignoreUpdated = ensureFernignoreEntries(outputDir);
+  ensureGitattributesEntries(outputDir);
   if (migrator.fernignoreExists() && fernignorePatterns.length > 0) {
     const action = options?.fernignoreAction ?? "skip";
     if (action === "migrate") {
@@ -2078,7 +2693,7 @@ function parseGitLog(log) {
     return { sha, authorName, authorEmail, message };
   });
 }
-var REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml"];
+var REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml", ".gitattributes"];
 function ensureFernignoreEntries(outputDir) {
   const fernignorePath = join5(outputDir, ".fernignore");
   let content = "";
@@ -2102,6 +2717,29 @@ function ensureFernignoreEntries(outputDir) {
   writeFileSync4(fernignorePath, content, "utf-8");
   return true;
 }
+var GITATTRIBUTES_ENTRIES = [".fern/replay.lock linguist-generated=true"];
+function ensureGitattributesEntries(outputDir) {
+  const gitattributesPath = join5(outputDir, ".gitattributes");
+  let content = "";
+  if (existsSync4(gitattributesPath)) {
+    content = readFileSync4(gitattributesPath, "utf-8");
+  }
+  const lines = content.split("\n");
+  const toAdd = [];
+  for (const entry of GITATTRIBUTES_ENTRIES) {
+    if (!lines.some((line) => line.trim() === entry)) {
+      toAdd.push(entry);
+    }
+  }
+  if (toAdd.length === 0) {
+    return;
+  }
+  if (content && !content.endsWith("\n")) {
+    content += "\n";
+  }
+  content += toAdd.join("\n") + "\n";
+  writeFileSync4(gitattributesPath, content, "utf-8");
+}
 function computeContentHash(patchContent) {
   const normalized = patchContent.split("\n").filter((line) => !line.startsWith("From ") && !line.startsWith("index ") && !line.startsWith("Date: ")).join("\n");
   return `sha256:${createHash3("sha256").update(normalized).digest("hex")}`;
@@ -2420,6 +3058,7 @@ export {
   FernignoreMigrator,
   GitClient,
   LockfileManager,
+  LockfileNotFoundError,
   ReplayApplicator,
   ReplayCommitter,
   ReplayDetector,