@fern-api/replay 0.6.0 → 0.6.2

package/dist/index.js

@@ -1,11 +1,1969 @@
-export { GitClient } from "./git/GitClient.js";
-export { isGenerationCommit, isReplayCommit, FERN_BOT_NAME, FERN_BOT_EMAIL, FERN_BOT_LOGIN, } from "./git/CommitDetection.js";
-export { LockfileManager } from "./LockfileManager.js";
-export { ReplayDetector } from "./ReplayDetector.js";
-export { threeWayMerge } from "./ThreeWayMerge.js";
-export { ReplayApplicator } from "./ReplayApplicator.js";
-export { ReplayCommitter } from "./ReplayCommitter.js";
-export { ReplayService } from "./ReplayService.js";
-export { FernignoreMigrator } from "./FernignoreMigrator.js";
-export { bootstrap, forget, reset, resolve, status, } from "./commands/index.js";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/git/GitClient.ts
+var GitClient_exports = {};
+__export(GitClient_exports, {
+  GitClient: () => GitClient
+});
+import { simpleGit } from "simple-git";
+var GitClient;
+var init_GitClient = __esm({
+  "src/git/GitClient.ts"() {
+    "use strict";
+    GitClient = class {
+      git;
+      repoPath;
+      constructor(repoPath) {
+        this.repoPath = repoPath;
+        this.git = simpleGit(repoPath);
+      }
+      async exec(args) {
+        return this.git.raw(args);
+      }
+      async execWithInput(args, input) {
+        const { spawn } = await import("child_process");
+        return new Promise((resolve2, reject) => {
+          const proc = spawn("git", args, { cwd: this.repoPath });
+          let stdout = "";
+          let stderr = "";
+          proc.stdout.on("data", (data) => {
+            stdout += data.toString();
+          });
+          proc.stderr.on("data", (data) => {
+            stderr += data.toString();
+          });
+          proc.on("close", (code) => {
+            if (code === 0) {
+              resolve2(stdout);
+            } else {
+              reject(new Error(`git ${args.join(" ")} failed (code ${code}): ${stderr}`));
+            }
+          });
+          proc.stdin.write(input);
+          proc.stdin.end();
+        });
+      }
+      async formatPatch(commitSha) {
+        return this.exec(["format-patch", "-1", commitSha, "--stdout"]);
+      }
+      async applyPatch(patchContent) {
+        await this.execWithInput(["am", "--3way"], patchContent);
+      }
+      async getTreeHash(commitSha) {
+        return (await this.exec(["rev-parse", `${commitSha}^{tree}`])).trim();
+      }
+      async showFile(treeish, filePath) {
+        try {
+          return await this.exec(["show", `${treeish}:${filePath}`]);
+        } catch {
+          return null;
+        }
+      }
+      async getCommitInfo(commitSha) {
+        const format = "%H%x00%an%x00%ae%x00%s";
+        const output = await this.exec(["log", "-1", `--format=${format}`, commitSha]);
+        const [sha, authorName, authorEmail, message] = output.trim().split("\0");
+        return { sha, authorName, authorEmail, message };
+      }
+      async getCommitParents(commitSha) {
+        const output = await this.exec(["rev-parse", `${commitSha}^@`]);
+        return output.trim().split("\n").filter(Boolean);
+      }
+      async detectRenames(fromTree, toTree) {
+        try {
+          const output = await this.exec(["diff", "--find-renames", "--name-status", fromTree, toTree]);
+          const renames = [];
+          for (const line of output.trim().split("\n")) {
+            if (!line) continue;
+            if (line.startsWith("R")) {
+              const parts = line.split("	");
+              if (parts.length >= 3) {
+                renames.push({ from: parts[1], to: parts[2] });
+              }
+            }
+          }
+          return renames;
+        } catch {
+          return [];
+        }
+      }
+      async isAncestor(commit, descendant) {
+        try {
+          const mergeBase = (await this.exec(["merge-base", commit, descendant])).trim();
+          return mergeBase === commit;
+        } catch {
+          return false;
+        }
+      }
+      async commitExists(sha) {
+        try {
+          const type = await this.exec(["cat-file", "-t", sha]);
+          return type.trim() === "commit";
+        } catch {
+          return false;
+        }
+      }
+      getRepoPath() {
+        return this.repoPath;
+      }
+    };
+  }
+});
+
+// src/index.ts
+init_GitClient();
+
+// src/git/CommitDetection.ts
+var FERN_BOT_NAME = "fern-api";
+var FERN_BOT_EMAIL = "115122769+fern-api[bot]@users.noreply.github.com";
+var FERN_BOT_LOGIN = "fern-api[bot]";
+var FERN_SUPPORT_NAMES = ["fern-support", "Fern Support"];
+function isGenerationCommit(commit) {
+  const isFernSupport = FERN_SUPPORT_NAMES.includes(commit.authorName);
+  const isBotAuthor = !isFernSupport && (commit.authorLogin === FERN_BOT_LOGIN || commit.authorEmail === FERN_BOT_EMAIL || commit.authorName === FERN_BOT_NAME);
+  const hasGenerationMarker = commit.message.startsWith("[fern-generated]") || commit.message.startsWith("[fern-replay]") || commit.message.includes("Generated by Fern") || commit.message.includes("\u{1F916} Generated with Fern") || // Squash merge of a Fern-generated PR uses the PR title as commit message.
+  // The default PR title is "SDK Generation" (from GithubStep's commitMessage default).
+  // GitHub appends "(#N)" for the PR number, e.g. "SDK Generation (#70)".
+  commit.message.startsWith("SDK Generation");
+  return isBotAuthor || hasGenerationMarker;
+}
+function isReplayCommit(commit) {
+  return commit.message.startsWith("[fern-replay]");
+}
+
+// src/LockfileManager.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from "fs";
+import { join, dirname } from "path";
+import { stringify, parse } from "yaml";
+var LOCKFILE_HEADER = "# DO NOT EDIT MANUALLY - Managed by Fern Replay\n";
+var LockfileManager = class {
+  outputDir;
+  lock = null;
+  constructor(outputDir) {
+    this.outputDir = outputDir;
+  }
+  get lockfilePath() {
+    return join(this.outputDir, ".fern", "replay.lock");
+  }
+  get customizationsPath() {
+    return join(this.outputDir, ".fern", "replay.yml");
+  }
+  exists() {
+    return existsSync(this.lockfilePath);
+  }
+  read() {
+    if (this.lock) {
+      return this.lock;
+    }
+    if (!this.exists()) {
+      throw new Error(`Lockfile not found: ${this.lockfilePath}`);
+    }
+    const content = readFileSync(this.lockfilePath, "utf-8");
+    this.lock = parse(content);
+    return this.lock;
+  }
+  initialize(firstGeneration) {
+    this.initializeInMemory(firstGeneration);
+    this.save();
+  }
+  /**
+   * Set up in-memory lock state without writing to disk.
+   * Useful for bootstrap dry-run where we need state for detection
+   * but don't want to persist anything.
+   */
+  initializeInMemory(firstGeneration) {
+    this.lock = {
+      version: "1.0",
+      generations: [firstGeneration],
+      current_generation: firstGeneration.commit_sha,
+      patches: []
+    };
+  }
+  save() {
+    if (!this.lock) {
+      throw new Error("No lockfile data to save. Call read() or initialize() first.");
+    }
+    const dir = dirname(this.lockfilePath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    const yaml = stringify(this.lock, {
+      lineWidth: 0,
+      blockQuote: "literal"
+    });
+    const content = LOCKFILE_HEADER + yaml;
+    const tmpPath = this.lockfilePath + ".tmp";
+    writeFileSync(tmpPath, content, "utf-8");
+    renameSync(tmpPath, this.lockfilePath);
+  }
+  addGeneration(record) {
+    this.ensureLoaded();
+    this.lock.generations.push(record);
+    this.lock.current_generation = record.commit_sha;
+  }
+  addPatch(patch) {
+    this.ensureLoaded();
+    this.lock.patches.push(patch);
+  }
+  updatePatch(patchId, updates) {
+    this.ensureLoaded();
+    const patch = this.lock.patches.find((p) => p.id === patchId);
+    if (!patch) {
+      throw new Error(`Patch not found: ${patchId}`);
+    }
+    Object.assign(patch, updates);
+  }
+  removePatch(patchId) {
+    this.ensureLoaded();
+    this.lock.patches = this.lock.patches.filter((p) => p.id !== patchId);
+  }
+  clearPatches() {
+    this.ensureLoaded();
+    this.lock.patches = [];
+  }
+  getPatches() {
+    this.ensureLoaded();
+    return this.lock.patches;
+  }
+  setReplaySkippedAt(timestamp) {
+    this.ensureLoaded();
+    this.lock.replay_skipped_at = timestamp;
+  }
+  clearReplaySkippedAt() {
+    this.ensureLoaded();
+    delete this.lock.replay_skipped_at;
+  }
+  isReplaySkipped() {
+    this.ensureLoaded();
+    return this.lock.replay_skipped_at != null;
+  }
+  getGeneration(commitSha) {
+    this.ensureLoaded();
+    return this.lock.generations.find((g) => g.commit_sha === commitSha);
+  }
+  getCustomizationsConfig() {
+    if (!existsSync(this.customizationsPath)) {
+      return {};
+    }
+    const content = readFileSync(this.customizationsPath, "utf-8");
+    return parse(content) ?? {};
+  }
+  ensureLoaded() {
+    if (!this.lock) {
+      throw new Error("No lockfile loaded. Call read() or initialize() first.");
+    }
+  }
+};
+
+// src/ReplayDetector.ts
+import { createHash } from "crypto";
+var INFRASTRUCTURE_FILES = /* @__PURE__ */ new Set([".fernignore"]);
+var ReplayDetector = class {
+  git;
+  lockManager;
+  sdkOutputDir;
+  warnings = [];
+  constructor(git, lockManager, sdkOutputDir) {
+    this.git = git;
+    this.lockManager = lockManager;
+    this.sdkOutputDir = sdkOutputDir;
+  }
+  async detectNewPatches() {
+    const lock = this.lockManager.read();
+    const lastGen = this.getLastGeneration(lock);
+    if (!lastGen) {
+      return [];
+    }
+    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.`
+      );
+      return [];
+    }
+    const isAncestor = await this.git.isAncestor(lastGen.commit_sha, "HEAD");
+    if (!isAncestor) {
+      return this.detectPatchesViaTreeDiff(lastGen);
+    }
+    const log = await this.git.exec([
+      "log",
+      "--format=%H%x00%an%x00%ae%x00%s",
+      `${lastGen.commit_sha}..HEAD`,
+      "--",
+      this.sdkOutputDir
+    ]);
+    if (!log.trim()) {
+      return [];
+    }
+    const commits = this.parseGitLog(log);
+    const newPatches = [];
+    for (const commit of commits) {
+      if (isGenerationCommit(commit)) {
+        continue;
+      }
+      const parents = await this.git.getCommitParents(commit.sha);
+      if (parents.length > 1) {
+        continue;
+      }
+      if (lock.patches.find((p) => p.original_commit === commit.sha)) {
+        continue;
+      }
+      const patchContent = await this.git.formatPatch(commit.sha);
+      const contentHash = this.computeContentHash(patchContent);
+      if (lock.patches.find((p) => p.content_hash === contentHash)) {
+        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;
+      }
+      newPatches.push({
+        id: `patch-${commit.sha.slice(0, 8)}`,
+        content_hash: contentHash,
+        original_commit: commit.sha,
+        original_message: commit.message,
+        original_author: `${commit.authorName} <${commit.authorEmail}>`,
+        base_generation: lastGen.commit_sha,
+        files,
+        patch_content: patchContent
+      });
+    }
+    return newPatches.reverse();
+  }
+  /**
+   * Compute content hash for deduplication.
+   * Removes commit SHA line and index lines before hashing,
+   * so rebased commits with same content produce the same hash.
+   */
+  computeContentHash(patchContent) {
+    const normalized = patchContent.split("\n").filter((line) => !line.startsWith("From ") && !line.startsWith("index ") && !line.startsWith("Date: ")).join("\n");
+    return `sha256:${createHash("sha256").update(normalized).digest("hex")}`;
+  }
+  /** Detect patches via tree diff for non-linear history. Returns a composite patch. */
+  async detectPatchesViaTreeDiff(lastGen) {
+    const filesOutput = await this.git.exec(["diff", "--name-only", lastGen.commit_sha, "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 [];
+    const diff = await this.git.exec(["diff", lastGen.commit_sha, "HEAD", "--", ...files]);
+    if (!diff.trim()) return [];
+    const contentHash = this.computeContentHash(diff);
+    const lock = this.lockManager.read();
+    if (lock.patches.some((p) => p.content_hash === contentHash)) {
+      return [];
+    }
+    const headSha = (await this.git.exec(["rev-parse", "HEAD"])).trim();
+    return [
+      {
+        id: `patch-composite-${headSha.slice(0, 8)}`,
+        content_hash: contentHash,
+        original_commit: headSha,
+        original_message: "Customer customizations (composite)",
+        original_author: "composite",
+        base_generation: lastGen.commit_sha,
+        files,
+        patch_content: diff
+      }
+    ];
+  }
+  parseGitLog(log) {
+    return log.trim().split("\n").map((line) => {
+      const [sha, authorName, authorEmail, message] = line.split("\0");
+      return { sha, authorName, authorEmail, message };
+    });
+  }
+  getLastGeneration(lock) {
+    return lock.generations.find((g) => g.commit_sha === lock.current_generation);
+  }
+};
+
+// src/ThreeWayMerge.ts
+import { diff3Merge } from "node-diff3";
+function threeWayMerge(base, ours, theirs) {
+  const baseLines = base.split("\n");
+  const oursLines = ours.split("\n");
+  const theirsLines = theirs.split("\n");
+  const regions = diff3Merge(oursLines, baseLines, theirsLines);
+  const outputLines = [];
+  const conflicts = [];
+  let currentLine = 1;
+  for (const region of regions) {
+    if (region.ok) {
+      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;
+    }
+  }
+  return {
+    content: outputLines.join("\n"),
+    hasConflicts: conflicts.length > 0,
+    conflicts
+  };
+}
+
+// src/ReplayApplicator.ts
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname as dirname2, extname, join as join2 } from "path";
+import { minimatch } from "minimatch";
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".svg",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".zip",
+  ".gz",
+  ".tar",
+  ".bz2",
+  ".7z",
+  ".rar",
+  ".jar",
+  ".war",
+  ".ear",
+  ".class",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".o",
+  ".a",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".otf",
+  ".mp3",
+  ".mp4",
+  ".avi",
+  ".mov",
+  ".wav",
+  ".flac",
+  ".sqlite",
+  ".db",
+  ".pyc",
+  ".pyo",
+  ".DS_Store"
+]);
+var ReplayApplicator = class {
+  git;
+  lockManager;
+  outputDir;
+  renameCache = /* @__PURE__ */ new Map();
+  fileTheirsAccumulator = /* @__PURE__ */ new Map();
+  constructor(git, lockManager, outputDir) {
+    this.git = git;
+    this.lockManager = lockManager;
+    this.outputDir = outputDir;
+  }
+  /** Reset inter-patch accumulator for a new cycle. */
+  resetAccumulator() {
+    this.fileTheirsAccumulator.clear();
+  }
+  /**
+   * Apply all patches, returning results for each.
+   * Skips patches that match exclude patterns in replay.yml
+   */
+  async applyPatches(patches) {
+    this.resetAccumulator();
+    const results = [];
+    for (const patch of patches) {
+      if (this.isExcluded(patch)) {
+        results.push({
+          patch,
+          status: "skipped",
+          method: "git-am"
+        });
+        continue;
+      }
+      const result = await this.applyPatchWithFallback(patch);
+      results.push(result);
+    }
+    return results;
+  }
+  /** Populate accumulator after git apply succeeds. */
+  async populateAccumulatorForPatch(patch, baseGen, currentTreeHash) {
+    if (!baseGen) return;
+    const tempDir = await mkdtemp(join2(tmpdir(), "replay-acc-"));
+    const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
+    const tempGit = new GitClient2(tempDir);
+    await tempGit.exec(["init"]);
+    await tempGit.exec(["config", "user.email", "replay@fern.com"]);
+    await tempGit.exec(["config", "user.name", "Fern Replay"]);
+    try {
+      for (const filePath of patch.files) {
+        if (isBinaryFile(filePath)) continue;
+        const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
+        const base = await this.git.showFile(baseGen.tree_hash, filePath);
+        const theirs = await this.applyPatchToContent(base, patch.patch_content, filePath, tempGit, tempDir);
+        if (theirs && base) {
+          this.fileTheirsAccumulator.set(resolvedPath, {
+            content: theirs,
+            baseGeneration: patch.base_generation
+          });
+        }
+      }
+    } finally {
+      await rm(tempDir, { recursive: true }).catch(() => {
+      });
+    }
+  }
+  async applyPatchWithFallback(patch) {
+    const baseGen = this.lockManager.getGeneration(patch.base_generation);
+    const lock = this.lockManager.read();
+    const currentGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
+    const currentTreeHash = currentGen?.tree_hash ?? baseGen?.tree_hash ?? "";
+    const needsAccumulation = await Promise.all(
+      patch.files.map(async (f) => {
+        if (!baseGen) return false;
+        const resolved = await this.resolveFilePath(f, baseGen.tree_hash, currentTreeHash);
+        return this.fileTheirsAccumulator.has(resolved);
+      })
+    ).then((results) => results.some(Boolean));
+    if (!needsAccumulation) {
+      const snapshots = /* @__PURE__ */ new Map();
+      const resolvedFiles = {};
+      for (const filePath of patch.files) {
+        const resolvedPath = baseGen ? await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash) : filePath;
+        if (resolvedPath !== filePath) {
+          resolvedFiles[filePath] = resolvedPath;
+        }
+        const fullPath = join2(this.outputDir, resolvedPath);
+        snapshots.set(resolvedPath, await readFile(fullPath, "utf-8").catch(() => null));
+      }
+      try {
+        await this.git.execWithInput(["apply", "--3way"], patch.patch_content);
+        await this.populateAccumulatorForPatch(patch, baseGen, currentTreeHash);
+        return {
+          patch,
+          status: "applied",
+          method: "git-am",
+          ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
+        };
+      } catch {
+        for (const [resolvedPath, content] of snapshots) {
+          if (content != null) {
+            await writeFile(join2(this.outputDir, resolvedPath), content);
+          }
+        }
+      }
+    }
+    return this.applyWithThreeWayMerge(patch);
+  }
+  async applyWithThreeWayMerge(patch) {
+    const fileResults = [];
+    const resolvedFiles = {};
+    const tempDir = await mkdtemp(join2(tmpdir(), "replay-"));
+    const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
+    const tempGit = new GitClient2(tempDir);
+    await tempGit.exec(["init"]);
+    await tempGit.exec(["config", "user.email", "replay@fern.com"]);
+    await tempGit.exec(["config", "user.name", "Fern Replay"]);
+    try {
+      for (const filePath of patch.files) {
+        if (isBinaryFile(filePath)) {
+          fileResults.push({
+            file: filePath,
+            status: "skipped",
+            reason: "binary-file"
+          });
+          continue;
+        }
+        const result = await this.mergeFile(patch, filePath, tempGit, tempDir);
+        if (result.file !== filePath) {
+          resolvedFiles[filePath] = result.file;
+        }
+        fileResults.push(result);
+      }
+    } finally {
+      await rm(tempDir, { recursive: true }).catch(() => {
+      });
+    }
+    const conflictFiles = fileResults.filter((r) => r.status === "conflict");
+    const hasConflicts = conflictFiles.length > 0;
+    const conflictReason = hasConflicts ? conflictFiles.some((f) => f.conflictReason === "base-generation-mismatch") ? "base-generation-mismatch" : conflictFiles[0]?.conflictReason : void 0;
+    return {
+      patch,
+      status: hasConflicts ? "conflict" : "applied",
+      method: "3way-merge",
+      fileResults,
+      conflictReason,
+      ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
+    };
+  }
+  async mergeFile(patch, filePath, tempGit, tempDir) {
+    try {
+      const baseGen = this.lockManager.getGeneration(patch.base_generation);
+      if (!baseGen) {
+        return { file: filePath, status: "skipped", reason: "base-generation-not-found" };
+      }
+      const lock = this.lockManager.read();
+      const currentGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
+      const currentTreeHash = currentGen?.tree_hash ?? baseGen.tree_hash;
+      const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
+      const metadata = {
+        patchId: patch.id,
+        patchMessage: patch.original_message,
+        baseGeneration: patch.base_generation,
+        currentGeneration: lock.current_generation
+      };
+      let base = await this.git.showFile(baseGen.tree_hash, filePath);
+      let renameSourcePath;
+      if (!base) {
+        const renameSource = this.extractRenameSource(patch.patch_content, filePath);
+        if (renameSource) {
+          base = await this.git.showFile(baseGen.tree_hash, renameSource);
+          renameSourcePath = renameSource;
+        }
+      }
+      const oursPath = 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 useAccumulatorAsMergeBase = false;
+      const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
+      if (!theirs && base && accumulatorEntry) {
+        theirs = await this.applyPatchToContent(
+          accumulatorEntry.content,
+          patch.patch_content,
+          filePath,
+          tempGit,
+          tempDir
+        );
+        if (theirs) {
+          useAccumulatorAsMergeBase = true;
+        }
+      }
+      let effective_theirs = theirs;
+      let baseMismatchSkipped = false;
+      if (theirs && base && !useAccumulatorAsMergeBase) {
+        if (accumulatorEntry && accumulatorEntry.baseGeneration === patch.base_generation) {
+          try {
+            const preMerged = threeWayMerge(base, accumulatorEntry.content, theirs);
+            if (!preMerged.hasConflicts) {
+              effective_theirs = preMerged.content;
+            } else {
+              effective_theirs = theirs;
+            }
+          } catch {
+            effective_theirs = theirs;
+          }
+        } else if (accumulatorEntry) {
+          baseMismatchSkipped = true;
+        }
+      }
+      if (!base && !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) {
+        const merged2 = threeWayMerge("", ours, effective_theirs);
+        const outDir2 = dirname2(oursPath);
+        await mkdir(outDir2, { recursive: true });
+        await writeFile(oursPath, merged2.content);
+        if (merged2.hasConflicts) {
+          return {
+            file: resolvedPath,
+            status: "conflict",
+            conflicts: merged2.conflicts,
+            conflictReason: "new-file-both",
+            conflictMetadata: metadata
+          };
+        }
+        return { file: resolvedPath, status: "merged" };
+      }
+      if (!effective_theirs) {
+        return {
+          file: resolvedPath,
+          status: "skipped",
+          reason: "missing-content"
+        };
+      }
+      if (!base || !ours) {
+        return {
+          file: resolvedPath,
+          status: "skipped",
+          reason: "missing-content"
+        };
+      }
+      const mergeBase = useAccumulatorAsMergeBase && accumulatorEntry ? accumulatorEntry.content : base;
+      const merged = threeWayMerge(mergeBase, ours, effective_theirs);
+      const outDir = dirname2(oursPath);
+      await mkdir(outDir, { recursive: true });
+      await writeFile(oursPath, merged.content);
+      if (effective_theirs && base) {
+        this.fileTheirsAccumulator.set(resolvedPath, {
+          content: effective_theirs,
+          baseGeneration: patch.base_generation
+        });
+      }
+      if (merged.hasConflicts) {
+        return {
+          file: resolvedPath,
+          status: "conflict",
+          conflicts: merged.conflicts,
+          conflictReason: baseMismatchSkipped ? "base-generation-mismatch" : "same-line-edit",
+          conflictMetadata: metadata
+        };
+      }
+      return { file: resolvedPath, status: "merged" };
+    } catch (error) {
+      return {
+        file: filePath,
+        status: "skipped",
+        reason: `error: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  isExcluded(patch) {
+    const config = this.lockManager.getCustomizationsConfig();
+    if (!config.exclude) return false;
+    return patch.files.some((file) => config.exclude.some((pattern) => minimatch(file, pattern)));
+  }
+  async resolveFilePath(filePath, baseTreeHash, currentTreeHash) {
+    const config = this.lockManager.getCustomizationsConfig();
+    if (config.moves) {
+      for (const move of config.moves) {
+        if (minimatch(filePath, move.from) || filePath === move.from) {
+          if (filePath === move.from) {
+            return move.to;
+          }
+          const fromBase = move.from.replace(/\*\*.*$/, "");
+          const toBase = move.to.replace(/\*\*.*$/, "");
+          if (filePath.startsWith(fromBase)) {
+            return toBase + filePath.slice(fromBase.length);
+          }
+        }
+      }
+    }
+    const cacheKey = `${baseTreeHash}:${currentTreeHash}`;
+    let renames = this.renameCache.get(cacheKey);
+    if (!renames) {
+      renames = await this.git.detectRenames(baseTreeHash, currentTreeHash);
+      this.renameCache.set(cacheKey, renames);
+    }
+    const gitRename = renames.find((r) => r.from === filePath);
+    if (gitRename) {
+      return gitRename.to;
+    }
+    return filePath;
+  }
+  async applyPatchToContent(base, patchContent, filePath, tempGit, tempDir, sourceFilePath) {
+    if (!base) {
+      return this.extractNewFileFromPatch(patchContent, filePath);
+    }
+    const fileDiff = this.extractFileDiff(patchContent, filePath);
+    if (!fileDiff) return null;
+    try {
+      if (sourceFilePath) {
+        const tempSourcePath = join2(tempDir, sourceFilePath);
+        await mkdir(dirname2(tempSourcePath), { recursive: true });
+        await writeFile(tempSourcePath, base);
+        await tempGit.exec(["add", sourceFilePath]);
+        await tempGit.exec([
+          "commit",
+          "-m",
+          `base for rename ${sourceFilePath} -> ${filePath}`,
+          "--allow-empty"
+        ]);
+        await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
+        const tempTargetPath = join2(tempDir, filePath);
+        return await readFile(tempTargetPath, "utf-8");
+      }
+      const tempFilePath = join2(tempDir, filePath);
+      await mkdir(dirname2(tempFilePath), { recursive: true });
+      await writeFile(tempFilePath, base);
+      await tempGit.exec(["add", filePath]);
+      await tempGit.exec(["commit", "-m", `base for ${filePath}`, "--allow-empty"]);
+      await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
+      return await readFile(tempFilePath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  extractFileDiff(patchContent, filePath) {
+    const lines = patchContent.split("\n");
+    const diffLines = [];
+    let inTargetFile = false;
+    for (const line of lines) {
+      if (line.startsWith("diff --git")) {
+        if (inTargetFile) {
+          break;
+        }
+        if (isDiffLineForFile(line, filePath)) {
+          inTargetFile = true;
+          diffLines.push(line);
+        }
+        continue;
+      }
+      if (inTargetFile) {
+        diffLines.push(line);
+      }
+    }
+    return diffLines.length > 0 ? diffLines.join("\n") + "\n" : null;
+  }
+  extractRenameSource(patchContent, targetFilePath) {
+    const lines = patchContent.split("\n");
+    let inTargetFile = false;
+    for (const line of lines) {
+      if (line.startsWith("diff --git")) {
+        if (inTargetFile) break;
+        inTargetFile = isDiffLineForFile(line, targetFilePath);
+        continue;
+      }
+      if (!inTargetFile) continue;
+      if (line.startsWith("@@")) break;
+      if (line.startsWith("rename from ")) {
+        return line.slice("rename from ".length);
+      }
+    }
+    return null;
+  }
+  extractNewFileFromPatch(patchContent, filePath) {
+    const lines = patchContent.split("\n");
+    const addedLines = [];
+    let inTargetFile = false;
+    let inHunk = false;
+    let noTrailingNewline = false;
+    for (const line of lines) {
+      if (line.startsWith("diff --git")) {
+        if (inTargetFile) break;
+        inTargetFile = isDiffLineForFile(line, filePath);
+        inHunk = false;
+        continue;
+      }
+      if (!inTargetFile) continue;
+      if (line.startsWith("@@")) {
+        inHunk = true;
+        continue;
+      }
+      if (!inHunk) continue;
+      if (line === "\") {
+        noTrailingNewline = true;
+        continue;
+      }
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        addedLines.push(line.slice(1));
+      }
+    }
+    if (addedLines.length === 0) return null;
+    return addedLines.join("\n") + (noTrailingNewline ? "" : "\n");
+  }
+};
+function isBinaryFile(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  return BINARY_EXTENSIONS.has(ext);
+}
+function isDiffLineForFile(diffLine, filePath) {
+  const match = diffLine.match(/^diff --git a\/.+ b\/(.+)$/);
+  return match !== null && match[1] === filePath;
+}
+
+// src/ReplayCommitter.ts
+var ReplayCommitter = class {
+  git;
+  outputDir;
+  constructor(git, outputDir) {
+    this.git = git;
+    this.outputDir = outputDir;
+  }
+  async commitGeneration(message, options) {
+    await this.stageAll();
+    if (!await this.hasStagedChanges()) {
+      return (await this.git.exec(["rev-parse", "HEAD"])).trim();
+    }
+    let fullMessage = `[fern-generated] ${message}
+
+Generated by Fern`;
+    if (options?.cliVersion) {
+      fullMessage += `
+CLI Version: ${options.cliVersion}`;
+    }
+    if (options?.generatorVersions && Object.keys(options.generatorVersions).length > 0) {
+      fullMessage += "\nGenerators:";
+      for (const [name, version] of Object.entries(options.generatorVersions)) {
+        fullMessage += `
+  - ${name}: ${version}`;
+      }
+    }
+    await this.git.exec(["commit", "-m", fullMessage]);
+    return (await this.git.exec(["rev-parse", "HEAD"])).trim();
+  }
+  async commitReplay(_patchCount, patches) {
+    await this.stageAll();
+    if (!await this.hasStagedChanges()) {
+      return (await this.git.exec(["rev-parse", "HEAD"])).trim();
+    }
+    let fullMessage = `[fern-replay] Applied customizations`;
+    if (patches && patches.length > 0) {
+      fullMessage += "\n\nPatches replayed:";
+      for (const patch of patches) {
+        fullMessage += `
+  - ${patch.id}: ${patch.original_message}`;
+      }
+    }
+    await this.git.exec(["commit", "-m", fullMessage]);
+    return (await this.git.exec(["rev-parse", "HEAD"])).trim();
+  }
+  async createGenerationRecord(options) {
+    const commitSha = (await this.git.exec(["rev-parse", "HEAD"])).trim();
+    const treeHash = await this.getTreeHash(commitSha);
+    return {
+      commit_sha: commitSha,
+      tree_hash: treeHash,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      cli_version: options?.cliVersion ?? "unknown",
+      generator_versions: options?.generatorVersions ?? {},
+      base_branch_head: options?.baseBranchHead
+    };
+  }
+  async stageAll() {
+    await this.git.exec(["add", "-A", this.outputDir]);
+  }
+  async hasStagedChanges() {
+    const output = await this.git.exec(["diff", "--cached", "--name-only"]);
+    return output.trim().length > 0;
+  }
+  async getTreeHash(commitSha) {
+    return this.git.getTreeHash(commitSha);
+  }
+};
+
+// src/ReplayService.ts
+init_GitClient();
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
+import { minimatch as minimatch2 } from "minimatch";
+var ReplayService = class {
+  git;
+  detector;
+  applicator;
+  committer;
+  lockManager;
+  outputDir;
+  constructor(outputDir, _config) {
+    const git = new GitClient(outputDir);
+    this.git = git;
+    this.outputDir = outputDir;
+    this.lockManager = new LockfileManager(outputDir);
+    this.detector = new ReplayDetector(git, this.lockManager, outputDir);
+    this.applicator = new ReplayApplicator(git, this.lockManager, outputDir);
+    this.committer = new ReplayCommitter(git, outputDir);
+  }
+  async runReplay(options) {
+    if (options?.skipApplication) {
+      return this.handleSkipApplication(options);
+    }
+    const flow = this.determineFlow();
+    switch (flow) {
+      case "first-generation":
+        return this.handleFirstGeneration(options);
+      case "no-patches":
+        return this.handleNoPatchesRegeneration(options);
+      case "normal-regeneration":
+        return this.handleNormalRegeneration(options);
+    }
+  }
+  /**
+   * Sync the lockfile after a divergent PR was squash-merged.
+   * Call this BEFORE runReplay() when the CLI detects a merged divergent PR.
+   *
+   * After updating the generation record, re-detects customer patches via
+   * tree diff between the generation tag (pure generation tree) and HEAD
+   * (which includes customer customizations after squash merge). This ensures
+   * patches survive the squash merge → regenerate cycle even when the lockfile
+   * was restored from the base branch during conflict PR creation.
+   */
+  async syncFromDivergentMerge(generationCommitSha, options) {
+    const treeHash = await this.git.getTreeHash(generationCommitSha);
+    const timestamp = (await this.git.exec(["log", "-1", "--format=%aI", generationCommitSha])).trim();
+    const record = {
+      commit_sha: generationCommitSha,
+      tree_hash: treeHash,
+      timestamp,
+      cli_version: options?.cliVersion ?? "unknown",
+      generator_versions: options?.generatorVersions ?? {},
+      base_branch_head: options?.baseBranchHead
+    };
+    if (!this.lockManager.exists()) {
+      this.lockManager.initializeInMemory(record);
+    } else {
+      this.lockManager.read();
+      this.lockManager.addGeneration(record);
+      this.lockManager.clearPatches();
+    }
+    this.lockManager.save();
+    try {
+      const redetectedPatches = await this.detector.detectNewPatches();
+      if (redetectedPatches.length > 0) {
+        for (const patch of redetectedPatches) {
+          this.lockManager.addPatch(patch);
+        }
+        this.lockManager.save();
+      }
+    } catch {
+    }
+  }
+  determineFlow() {
+    if (!this.lockManager.exists()) {
+      return "first-generation";
+    }
+    const lock = this.lockManager.read();
+    if (lock.patches.length === 0) {
+      return "no-patches";
+    }
+    return "normal-regeneration";
+  }
+  async handleFirstGeneration(options) {
+    if (options?.dryRun) {
+      return {
+        flow: "first-generation",
+        patchesDetected: 0,
+        patchesApplied: 0,
+        patchesWithConflicts: 0,
+        patchesSkipped: 0,
+        conflicts: []
+      };
+    }
+    const commitOpts = options ? {
+      cliVersion: options.cliVersion ?? "unknown",
+      generatorVersions: options.generatorVersions ?? {},
+      baseBranchHead: options.baseBranchHead
+    } : void 0;
+    await this.committer.commitGeneration("Initial SDK generation", commitOpts);
+    const genRecord = await this.committer.createGenerationRecord(commitOpts);
+    this.lockManager.initialize(genRecord);
+    return {
+      flow: "first-generation",
+      patchesDetected: 0,
+      patchesApplied: 0,
+      patchesWithConflicts: 0,
+      patchesSkipped: 0,
+      conflicts: []
+    };
+  }
+  /**
+   * Skip-application mode: commit the generation and update the lockfile
+   * but don't detect or apply patches. Sets a marker so the next normal
+   * run skips revert detection in preGenerationRebase().
+   */
+  async handleSkipApplication(options) {
+    const commitOpts = options ? {
+      cliVersion: options.cliVersion ?? "unknown",
+      generatorVersions: options.generatorVersions ?? {},
+      baseBranchHead: options.baseBranchHead
+    } : void 0;
+    await this.committer.commitGeneration("Update SDK (replay skipped)", commitOpts);
+    const genRecord = await this.committer.createGenerationRecord(commitOpts);
+    if (this.lockManager.exists()) {
+      this.lockManager.read();
+      this.lockManager.addGeneration(genRecord);
+    } else {
+      this.lockManager.initializeInMemory(genRecord);
+    }
+    this.lockManager.setReplaySkippedAt((/* @__PURE__ */ new Date()).toISOString());
+    this.lockManager.save();
+    if (!options?.stageOnly) {
+      await this.committer.commitReplay(0);
+    } else {
+      await this.committer.stageAll();
+    }
+    return {
+      flow: "skip-application",
+      patchesDetected: 0,
+      patchesApplied: 0,
+      patchesWithConflicts: 0,
+      patchesSkipped: 0,
+      conflicts: []
+    };
+  }
+  async handleNoPatchesRegeneration(options) {
+    const newPatches = await this.detector.detectNewPatches();
+    const warnings = [...this.detector.warnings];
+    if (options?.dryRun) {
+      return {
+        flow: "no-patches",
+        patchesDetected: newPatches.length,
+        patchesApplied: 0,
+        patchesWithConflicts: 0,
+        patchesSkipped: 0,
+        conflicts: [],
+        wouldApply: newPatches,
+        warnings: warnings.length > 0 ? warnings : void 0
+      };
+    }
+    const commitOpts = options ? {
+      cliVersion: options.cliVersion ?? "unknown",
+      generatorVersions: options.generatorVersions ?? {},
+      baseBranchHead: options.baseBranchHead
+    } : void 0;
+    await this.committer.commitGeneration("Update SDK", commitOpts);
+    const genRecord = await this.committer.createGenerationRecord(commitOpts);
+    this.lockManager.addGeneration(genRecord);
+    let results = [];
+    if (newPatches.length > 0) {
+      results = await this.applicator.applyPatches(newPatches);
+    }
+    const rebaseCounts = await this.rebasePatches(results, genRecord.commit_sha);
+    for (const patch of newPatches) {
+      if (!rebaseCounts.absorbedPatchIds.has(patch.id)) {
+        this.lockManager.addPatch(patch);
+      }
+    }
+    this.lockManager.save();
+    if (newPatches.length > 0) {
+      if (!options?.stageOnly) {
+        const appliedCount = results.filter((r) => r.status === "applied" || r.status === "conflict").length;
+        if (appliedCount > 0) {
+          await this.committer.commitReplay(appliedCount, newPatches);
+        }
+      } else {
+        await this.committer.stageAll();
+      }
+    }
+    return this.buildReport("no-patches", newPatches, results, options, warnings, rebaseCounts);
+  }
+  async handleNormalRegeneration(options) {
+    if (options?.dryRun) {
+      const existingPatches2 = this.lockManager.getPatches();
+      const newPatches2 = await this.detector.detectNewPatches();
+      const warnings2 = [...this.detector.warnings];
+      const allPatches2 = [...existingPatches2, ...newPatches2];
+      return {
+        flow: "normal-regeneration",
+        patchesDetected: allPatches2.length,
+        patchesApplied: 0,
+        patchesWithConflicts: 0,
+        patchesSkipped: 0,
+        conflicts: [],
+        wouldApply: allPatches2,
+        warnings: warnings2.length > 0 ? warnings2 : void 0
+      };
+    }
+    let existingPatches = this.lockManager.getPatches();
+    const preRebaseCounts = await this.preGenerationRebase(existingPatches);
+    existingPatches = this.lockManager.getPatches();
+    const seenHashes = /* @__PURE__ */ new Set();
+    for (const p of existingPatches) {
+      if (seenHashes.has(p.content_hash)) {
+        this.lockManager.removePatch(p.id);
+      } else {
+        seenHashes.add(p.content_hash);
+      }
+    }
+    existingPatches = this.lockManager.getPatches();
+    const newPatches = await this.detector.detectNewPatches();
+    const warnings = [...this.detector.warnings];
+    const allPatches = [...existingPatches, ...newPatches];
+    const commitOpts = options ? {
+      cliVersion: options.cliVersion ?? "unknown",
+      generatorVersions: options.generatorVersions ?? {},
+      baseBranchHead: options.baseBranchHead
+    } : void 0;
+    await this.committer.commitGeneration("Update SDK", commitOpts);
+    const genRecord = await this.committer.createGenerationRecord(commitOpts);
+    this.lockManager.addGeneration(genRecord);
+    const results = await this.applicator.applyPatches(allPatches);
+    const rebaseCounts = await this.rebasePatches(results, genRecord.commit_sha);
+    for (const patch of newPatches) {
+      if (!rebaseCounts.absorbedPatchIds.has(patch.id)) {
+        this.lockManager.addPatch(patch);
+      }
+    }
+    this.lockManager.save();
+    if (options?.stageOnly) {
+      await this.committer.stageAll();
+    } else {
+      const appliedCount = results.filter((r) => r.status === "applied" || r.status === "conflict").length;
+      if (appliedCount > 0) {
+        await this.committer.commitReplay(appliedCount, allPatches);
+      }
+    }
+    return this.buildReport(
+      "normal-regeneration",
+      allPatches,
+      results,
+      options,
+      warnings,
+      rebaseCounts,
+      preRebaseCounts
+    );
+  }
+  /**
+   * Rebase cleanly applied patches so they are relative to the current generation.
+   * This prevents recurring conflicts on subsequent regenerations.
+   * Returns the number of patches rebased.
+   */
+  async rebasePatches(results, currentGenSha) {
+    let absorbed = 0;
+    let repointed = 0;
+    let contentRebased = 0;
+    let keptAsUserOwned = 0;
+    const seenContentHashes = /* @__PURE__ */ new Set();
+    const absorbedPatchIds = /* @__PURE__ */ new Set();
+    for (const result of results) {
+      if (result.resolvedFiles && Object.keys(result.resolvedFiles).length > 0) {
+        const patch = result.patch;
+        const updatedFiles = patch.files.map((f) => result.resolvedFiles[f] ?? f);
+        patch.files = updatedFiles;
+        try {
+          this.lockManager.updatePatch(patch.id, { files: updatedFiles });
+        } catch {
+        }
+      }
+    }
+    for (const result of results) {
+      if (result.status === "conflict" && result.fileResults) {
+        await this.trimAbsorbedFiles(result, currentGenSha);
+        continue;
+      }
+      if (result.status !== "applied") continue;
+      const patch = result.patch;
+      if (patch.base_generation === currentGenSha) continue;
+      try {
+        const fernignorePatterns = this.readFernignorePatterns();
+        const isUserOwned = await Promise.all(
+          patch.files.map(async (file) => {
+            if (file === ".fernignore") {
+              return true;
+            }
+            if (fernignorePatterns.some((p) => file === p || minimatch2(file, p))) {
+              return true;
+            }
+            const content = await this.git.showFile(currentGenSha, file);
+            return content === null;
+          })
+        );
+        const hasUserOwnedFiles = isUserOwned.some(Boolean);
+        if (hasUserOwnedFiles) {
+          this.lockManager.updatePatch(patch.id, {
+            base_generation: currentGenSha
+          });
+          keptAsUserOwned++;
+          continue;
+        }
+        const diff = await this.git.exec(["diff", currentGenSha, "--", ...patch.files]).catch(() => null);
+        if (!diff || !diff.trim()) {
+          this.lockManager.removePatch(patch.id);
+          absorbedPatchIds.add(patch.id);
+          absorbed++;
+          continue;
+        }
+        const newContentHash = this.detector.computeContentHash(diff);
+        if (seenContentHashes.has(newContentHash)) {
+          this.lockManager.removePatch(patch.id);
+          absorbedPatchIds.add(patch.id);
+          absorbed++;
+          continue;
+        }
+        seenContentHashes.add(newContentHash);
+        this.lockManager.updatePatch(patch.id, {
+          base_generation: currentGenSha,
+          patch_content: diff,
+          content_hash: newContentHash
+        });
+        contentRebased++;
+      } catch {
+      }
+    }
+    return { absorbed, repointed, contentRebased, keptAsUserOwned, absorbedPatchIds };
+  }
+  /**
+   * For conflict patches with mixed results (some files merged, some conflicted),
+   * check if the cleanly merged files were absorbed by the generator (empty diff).
+   * If so, remove them from patch.files so they don't pollute the pre-generation
+   * rebase conflict marker check (`git grep <<<<<<< -- ...patch.files`).
+   *
+   * Non-absorbed clean files stay in patch.files — removing them would lose
+   * the customization on the next generation.
+   */
+  async trimAbsorbedFiles(result, currentGenSha) {
+    const cleanFiles = result.fileResults.filter((f) => f.status === "merged").map((f) => f.file);
+    if (cleanFiles.length === 0) return;
+    const patch = result.patch;
+    const fernignorePatterns = this.readFernignorePatterns();
+    const generatorCleanFiles = [];
+    for (const file of cleanFiles) {
+      if (file === ".fernignore") continue;
+      if (fernignorePatterns.some((p) => file === p || minimatch2(file, p))) continue;
+      const content = await this.git.showFile(currentGenSha, file);
+      if (content === null) continue;
+      generatorCleanFiles.push(file);
+    }
+    if (generatorCleanFiles.length === 0) return;
+    const absorbedFiles = /* @__PURE__ */ new Set();
+    for (const file of generatorCleanFiles) {
+      try {
+        const diff = await this.git.exec(["diff", currentGenSha, "--", file]).catch(() => null);
+        if (!diff || !diff.trim()) {
+          absorbedFiles.add(file);
+        }
+      } catch {
+      }
+    }
+    if (absorbedFiles.size === 0) return;
+    const remainingFiles = patch.files.filter((f) => !absorbedFiles.has(f));
+    if (remainingFiles.length === patch.files.length) return;
+    try {
+      this.lockManager.updatePatch(patch.id, { files: remainingFiles });
+    } catch {
+      patch.files = remainingFiles;
+    }
+  }
+  /**
+   * Pre-generation rebase: update patches using the customer's current state.
+   * Called BEFORE commitGeneration() while HEAD has customer code.
+   */
+  async preGenerationRebase(patches) {
+    const lock = this.lockManager.read();
+    const currentGen = lock.current_generation;
+    if (this.lockManager.isReplaySkipped()) {
+      this.lockManager.clearReplaySkippedAt();
+      return { conflictResolved: 0, conflictAbsorbed: 0, contentRefreshed: 0 };
+    }
+    let conflictResolved = 0;
+    let conflictAbsorbed = 0;
+    let contentRefreshed = 0;
+    for (const patch of patches) {
+      if (patch.base_generation === currentGen) {
+        try {
+          const diff = await this.git.exec(["diff", currentGen, "HEAD", "--", ...patch.files]).catch(() => null);
+          if (diff === null) continue;
+          if (!diff.trim()) {
+            this.lockManager.removePatch(patch.id);
+            contentRefreshed++;
+            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);
+            const newFiles = filesOutput ? filesOutput.trim().split("\n").filter(Boolean).filter((f) => !f.startsWith(".fern/")) : patch.files;
+            if (newFiles.length === 0) {
+              this.lockManager.removePatch(patch.id);
+            } else {
+              this.lockManager.updatePatch(patch.id, {
+                patch_content: diff,
+                content_hash: newContentHash,
+                files: newFiles
+              });
+            }
+            contentRefreshed++;
+          }
+        } catch {
+        }
+        continue;
+      }
+      try {
+        const markerFiles = await this.git.exec(["grep", "-l", "<<<<<<<", "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;
+        if (!diff.trim()) {
+          this.lockManager.removePatch(patch.id);
+          conflictAbsorbed++;
+          continue;
+        }
+        const newContentHash = this.detector.computeContentHash(diff);
+        this.lockManager.updatePatch(patch.id, {
+          base_generation: currentGen,
+          patch_content: diff,
+          content_hash: newContentHash
+        });
+        conflictResolved++;
+      } catch {
+      }
+    }
+    return { conflictResolved, conflictAbsorbed, contentRefreshed };
+  }
+  readFernignorePatterns() {
+    const fernignorePath = join3(this.outputDir, ".fernignore");
+    if (!existsSync2(fernignorePath)) return [];
+    return readFileSync2(fernignorePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+  }
+  buildReport(flow, patches, results, options, warnings, rebaseCounts, preRebaseCounts) {
+    const conflictResults = results.filter((r) => r.status === "conflict");
+    const conflictDetails = conflictResults.map((r) => {
+      const conflictFiles = r.fileResults?.filter((f) => f.status === "conflict") ?? [];
+      const cleanFiles = r.fileResults?.filter((f) => f.status === "merged").map((f) => f.file) ?? [];
+      return {
+        patchId: r.patch.id,
+        patchMessage: r.patch.original_message,
+        reason: r.conflictReason,
+        files: conflictFiles,
+        cleanFiles: cleanFiles.length > 0 ? cleanFiles : void 0
+      };
+    }).filter((d) => d.files.length > 0);
+    const partialCount = conflictDetails.filter((d) => d.cleanFiles && d.cleanFiles.length > 0).length;
+    return {
+      flow,
+      patchesDetected: patches.length,
+      patchesApplied: results.filter((r) => r.status === "applied").length,
+      patchesWithConflicts: conflictResults.length,
+      patchesSkipped: results.filter((r) => r.status === "skipped").length,
+      patchesPartiallyApplied: partialCount > 0 ? partialCount : void 0,
+      patchesAbsorbed: rebaseCounts && rebaseCounts.absorbed > 0 ? rebaseCounts.absorbed : void 0,
+      patchesRepointed: rebaseCounts && rebaseCounts.repointed > 0 ? rebaseCounts.repointed : void 0,
+      patchesContentRebased: rebaseCounts && rebaseCounts.contentRebased > 0 ? rebaseCounts.contentRebased : void 0,
+      patchesKeptAsUserOwned: rebaseCounts && rebaseCounts.keptAsUserOwned > 0 ? rebaseCounts.keptAsUserOwned : void 0,
+      patchesConflictResolved: preRebaseCounts && preRebaseCounts.conflictResolved + preRebaseCounts.conflictAbsorbed > 0 ? preRebaseCounts.conflictResolved + preRebaseCounts.conflictAbsorbed : void 0,
+      patchesRefreshed: preRebaseCounts && preRebaseCounts.contentRefreshed > 0 ? preRebaseCounts.contentRefreshed : void 0,
+      conflicts: conflictResults.flatMap((r) => r.fileResults?.filter((f) => f.status === "conflict") ?? []),
+      conflictDetails: conflictDetails.length > 0 ? conflictDetails : void 0,
+      wouldApply: options?.dryRun ? patches : void 0,
+      warnings: warnings && warnings.length > 0 ? warnings : void 0
+    };
+  }
+};
+
+// src/FernignoreMigrator.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname3, join as join4 } from "path";
+import { minimatch as minimatch3 } from "minimatch";
+import { parse as parse2, stringify as stringify2 } from "yaml";
+var FernignoreMigrator = class {
+  git;
+  lockManager;
+  outputDir;
+  constructor(git, lockManager, outputDir) {
+    this.git = git;
+    this.lockManager = lockManager;
+    this.outputDir = outputDir;
+  }
+  fernignoreExists() {
+    return existsSync3(join4(this.outputDir, ".fernignore"));
+  }
+  readFernignorePatterns() {
+    const fernignorePath = join4(this.outputDir, ".fernignore");
+    if (!existsSync3(fernignorePath)) {
+      return [];
+    }
+    const content = readFileSync3(fernignorePath, "utf-8");
+    return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+  }
+  /** Analyze .fernignore patterns vs git history. Creates synthetic patches for files differing from pristine generation. */
+  async analyzeMigration() {
+    const patterns = this.readFernignorePatterns();
+    const detector = new ReplayDetector(this.git, this.lockManager, this.outputDir);
+    const patches = await detector.detectNewPatches();
+    const trackedByBoth = [];
+    const fernignoreOnly = [];
+    const commitsOnly = [];
+    const syntheticPatches = [];
+    for (const pattern of patterns) {
+      const matchingPatch = patches.find((p) => p.files.some((f) => minimatch3(f, pattern) || f === pattern));
+      if (matchingPatch) {
+        trackedByBoth.push({
+          file: pattern,
+          commit: matchingPatch.original_commit
+        });
+      } else {
+        fernignoreOnly.push(pattern);
+      }
+    }
+    const lock = this.lockManager.read();
+    const currentGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
+    if (currentGen && fernignoreOnly.length > 0) {
+      const resolvedFiles = await this.resolvePatterns(fernignoreOnly);
+      const remainingFernignoreOnly = [];
+      for (const { pattern, files } of resolvedFiles) {
+        const patchFiles = [];
+        const diffParts = [];
+        for (const filePath of files) {
+          const pristine = await this.git.showFile(currentGen.tree_hash, filePath);
+          const currentContent = this.readFileContent(filePath);
+          if (currentContent === null) {
+            continue;
+          }
+          if (pristine === null) {
+            patchFiles.push(filePath);
+            diffParts.push(this.createNewFileDiff(filePath, currentContent));
+          } else if (pristine !== currentContent) {
+            patchFiles.push(filePath);
+            diffParts.push(this.createFileDiff(filePath, pristine, currentContent));
+          }
+        }
+        if (patchFiles.length > 0) {
+          const patchContent = diffParts.join("\n");
+          const contentHash = `sha256:${createHash2("sha256").update(patchContent).digest("hex")}`;
+          syntheticPatches.push({
+            id: `patch-fernignore-${createHash2("sha256").update(pattern).digest("hex").slice(0, 8)}`,
+            content_hash: contentHash,
+            original_commit: currentGen.commit_sha,
+            original_message: `[fernignore-migration] Customizations for ${pattern}`,
+            original_author: "Fern Replay <replay@buildwithfern.com>",
+            base_generation: currentGen.commit_sha,
+            files: patchFiles,
+            patch_content: patchContent
+          });
+          trackedByBoth.push({
+            file: pattern,
+            commit: `synthetic (differs from generated)`
+          });
+        } else {
+          remainingFernignoreOnly.push(pattern);
+        }
+      }
+      fernignoreOnly.length = 0;
+      fernignoreOnly.push(...remainingFernignoreOnly);
+    }
+    for (const patch of patches) {
+      const hasUnprotectedFiles = patch.files.some((f) => !patterns.some((p) => minimatch3(f, p) || f === p));
+      if (hasUnprotectedFiles) {
+        commitsOnly.push(patch);
+      }
+    }
+    return { trackedByBoth, fernignoreOnly, commitsOnly, syntheticPatches };
+  }
+  async resolvePatterns(patterns) {
+    const allFiles = (await this.git.exec(["ls-files"])).trim().split("\n").filter(Boolean);
+    const results = [];
+    for (const pattern of patterns) {
+      const matching = allFiles.filter(
+        (f) => minimatch3(f, pattern) || f === pattern || f.startsWith(pattern + "/")
+      );
+      results.push({ pattern, files: matching.length > 0 ? matching : [pattern] });
+    }
+    return results;
+  }
+  readFileContent(filePath) {
+    const fullPath = join4(this.outputDir, filePath);
+    if (!existsSync3(fullPath)) {
+      return null;
+    }
+    try {
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        return null;
+      }
+      return readFileSync3(fullPath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  createNewFileDiff(filePath, content) {
+    const lines = content.split("\n");
+    const hunks = lines.map((l) => `+${l}`).join("\n");
+    return [
+      `diff --git a/${filePath} b/${filePath}`,
+      "new file mode 100644",
+      `--- /dev/null`,
+      `+++ b/${filePath}`,
+      `@@ -0,0 +1,${lines.length} @@`,
+      hunks
+    ].join("\n");
+  }
+  createFileDiff(filePath, pristine, current) {
+    const oldLines = pristine.split("\n");
+    const newLines = current.split("\n");
+    const removals = oldLines.map((l) => `-${l}`).join("\n");
+    const additions = newLines.map((l) => `+${l}`).join("\n");
+    return [
+      `diff --git a/${filePath} b/${filePath}`,
+      `--- a/${filePath}`,
+      `+++ b/${filePath}`,
+      `@@ -1,${oldLines.length} +1,${newLines.length} @@`,
+      removals,
+      additions
+    ].join("\n");
+  }
+  async migrate() {
+    const analysis = await this.analyzeMigration();
+    const detector = new ReplayDetector(this.git, this.lockManager, this.outputDir);
+    const patches = await detector.detectNewPatches();
+    const warnings = [];
+    let patchesCreated = 0;
+    for (const patch of patches) {
+      this.lockManager.addPatch(patch);
+      patchesCreated++;
+    }
+    if (patchesCreated > 0) {
+      this.lockManager.save();
+    }
+    for (const file of analysis.fernignoreOnly) {
+      warnings.push(
+        `${file}: in .fernignore but no commit history found. Commit this file or keep in .fernignore as fallback.`
+      );
+    }
+    return {
+      patchesCreated,
+      filesSkipped: analysis.fernignoreOnly,
+      warnings
+    };
+  }
+  movePatternsToReplayYml(patterns) {
+    const replayYmlPath = join4(this.outputDir, ".fern", "replay.yml");
+    let config = {};
+    if (existsSync3(replayYmlPath)) {
+      const content = readFileSync3(replayYmlPath, "utf-8");
+      config = parse2(content) ?? {};
+    }
+    const existing = config.exclude ?? [];
+    const merged = [.../* @__PURE__ */ new Set([...existing, ...patterns])];
+    config.exclude = merged;
+    const dir = dirname3(replayYmlPath);
+    if (!existsSync3(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    writeFileSync2(replayYmlPath, stringify2(config, { lineWidth: 0 }), "utf-8");
+  }
+};
+
+// src/commands/bootstrap.ts
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
+init_GitClient();
+async function bootstrap(outputDir, options) {
+  const git = new GitClient(outputDir);
+  const lockManager = new LockfileManager(outputDir);
+  const maxCommits = options?.maxCommitsToScan ?? 500;
+  const warnings = [];
+  if (lockManager.exists() && !options?.force) {
+    return {
+      generationCommit: null,
+      patchesDetected: 0,
+      patchesCreated: 0,
+      patches: [],
+      fernignorePatterns: [],
+      fernignoreUpdated: false,
+      warnings: ["Replay lockfile already exists. Use --force to overwrite."],
+      staleGenerationsSkipped: 0,
+      scannedSinceGeneration: ""
+    };
+  }
+  const genCommits = await findAllGenerationCommits(git, maxCommits);
+  if (genCommits.length === 0) {
+    return {
+      generationCommit: null,
+      patchesDetected: 0,
+      patchesCreated: 0,
+      patches: [],
+      fernignorePatterns: [],
+      fernignoreUpdated: false,
+      warnings: [
+        "No generation commits found in the last " + maxCommits + " commits. Run 'fern generate' first to establish a baseline."
+      ],
+      staleGenerationsSkipped: 0,
+      scannedSinceGeneration: ""
+    };
+  }
+  const latestGen = genCommits[0];
+  const anchorSha = options?.importHistory ? latestGen.sha : (await git.exec(["rev-parse", "HEAD"])).trim();
+  const treeHash = await git.getTreeHash(anchorSha);
+  const genRecord = {
+    commit_sha: anchorSha,
+    tree_hash: treeHash,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    cli_version: "unknown",
+    generator_versions: {}
+  };
+  lockManager.initializeInMemory(genRecord);
+  const patches = options?.importHistory ? await findAllUserPatches(git, genCommits) : [];
+  const migrator = new FernignoreMigrator(git, lockManager, outputDir);
+  const fernignorePatterns = migrator.readFernignorePatterns();
+  let fernignoreAnalysis;
+  if (options?.importHistory && migrator.fernignoreExists() && fernignorePatterns.length > 0) {
+    fernignoreAnalysis = await migrator.analyzeMigration();
+    if (fernignoreAnalysis.syntheticPatches.length > 0) {
+      patches.push(...fernignoreAnalysis.syntheticPatches);
+    }
+    if (fernignoreAnalysis.fernignoreOnly.length > 0) {
+      for (const file of fernignoreAnalysis.fernignoreOnly) {
+        warnings.push(
+          `${file}: in .fernignore but no recent commits found since last generation. File may be stale, matches generated output, or does not exist. No customization to track.`
+        );
+      }
+    }
+  }
+  if (options?.dryRun) {
+    return {
+      generationCommit: latestGen,
+      patchesDetected: patches.length,
+      patchesCreated: 0,
+      patches,
+      fernignorePatterns,
+      fernignoreAnalysis,
+      fernignoreUpdated: false,
+      warnings,
+      staleGenerationsSkipped: genCommits.length - 1,
+      scannedSinceGeneration: latestGen.sha
+    };
+  }
+  for (const patch of patches) {
+    lockManager.addPatch(patch);
+  }
+  lockManager.save();
+  const fernignoreUpdated = ensureFernignoreEntries(outputDir);
+  if (migrator.fernignoreExists() && fernignorePatterns.length > 0) {
+    const action = options?.fernignoreAction ?? "skip";
+    if (action === "migrate") {
+      const patternsToExclude = fernignoreAnalysis?.fernignoreOnly ?? [];
+      if (patternsToExclude.length > 0) {
+        migrator.movePatternsToReplayYml(patternsToExclude);
+      }
+    }
+  }
+  return {
+    generationCommit: latestGen,
+    patchesDetected: patches.length,
+    patchesCreated: patches.length,
+    patches,
+    fernignorePatterns,
+    fernignoreAnalysis,
+    fernignoreUpdated,
+    warnings,
+    staleGenerationsSkipped: genCommits.length - 1,
+    scannedSinceGeneration: latestGen.sha
+  };
+}
+async function findAllGenerationCommits(git, maxCommits) {
+  const log = await git.exec(["log", "--format=%H%x00%an%x00%ae%x00%s", `-${maxCommits}`]);
+  if (!log.trim()) {
+    return [];
+  }
+  const genCommits = [];
+  for (const line of log.trim().split("\n")) {
+    if (!line) continue;
+    const [sha, authorName, authorEmail, message] = line.split("\0");
+    const commit = { sha, authorName, authorEmail, message };
+    if (isGenerationCommit(commit) && !isReplayCommit(commit)) {
+      genCommits.push(commit);
+    }
+  }
+  return genCommits;
+}
+async function findAllUserPatches(git, genCommits) {
+  const patches = [];
+  const seenHashes = /* @__PURE__ */ new Set();
+  const latestGen = genCommits[0];
+  const recentPatches = await extractUserPatches(git, latestGen.sha, "HEAD", latestGen.sha, seenHashes);
+  patches.push(...recentPatches);
+  return patches;
+}
+async function extractUserPatches(git, fromSha, toRef, baseGeneration, seenHashes) {
+  const log = await git.exec(["log", "--format=%H%x00%an%x00%ae%x00%s", `${fromSha}..${toRef}`]);
+  if (!log.trim()) {
+    return [];
+  }
+  const commits = parseGitLog(log);
+  const patches = [];
+  for (const commit of commits.reverse()) {
+    if (isGenerationCommit(commit)) continue;
+    const parents = await git.getCommitParents(commit.sha);
+    if (parents.length > 1) continue;
+    const patchContent = await git.formatPatch(commit.sha);
+    const contentHash = computeContentHash(patchContent);
+    if (seenHashes.has(contentHash)) continue;
+    seenHashes.add(contentHash);
+    const filesOutput = await git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
+    patches.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: baseGeneration,
+      files: filesOutput.trim().split("\n").filter(Boolean),
+      patch_content: patchContent
+    });
+  }
+  return patches;
+}
+function parseGitLog(log) {
+  return log.trim().split("\n").filter(Boolean).map((line) => {
+    const [sha, authorName, authorEmail, message] = line.split("\0");
+    return { sha, authorName, authorEmail, message };
+  });
+}
+var REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml"];
+function ensureFernignoreEntries(outputDir) {
+  const fernignorePath = join5(outputDir, ".fernignore");
+  let content = "";
+  if (existsSync4(fernignorePath)) {
+    content = readFileSync4(fernignorePath, "utf-8");
+  }
+  const lines = content.split("\n");
+  const toAdd = [];
+  for (const entry of REPLAY_FERNIGNORE_ENTRIES) {
+    if (!lines.some((line) => line.trim() === entry)) {
+      toAdd.push(entry);
+    }
+  }
+  if (toAdd.length === 0) {
+    return false;
+  }
+  if (content && !content.endsWith("\n")) {
+    content += "\n";
+  }
+  content += toAdd.join("\n") + "\n";
+  writeFileSync3(fernignorePath, content, "utf-8");
+  return true;
+}
+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")}`;
+}
+
+// src/commands/forget.ts
+import { minimatch as minimatch4 } from "minimatch";
+function forget(outputDir, filePattern, options) {
+  const lockManager = new LockfileManager(outputDir);
+  if (!lockManager.exists()) {
+    return { removed: [], notFound: true };
+  }
+  const lock = lockManager.read();
+  const matchingPatches = lock.patches.filter(
+    (patch) => patch.files.some((file) => file === filePattern || minimatch4(file, filePattern))
+  );
+  if (matchingPatches.length === 0) {
+    return { removed: [], notFound: true };
+  }
+  const removed = matchingPatches.map((p) => ({
+    id: p.id,
+    message: p.original_message,
+    files: p.files
+  }));
+  if (!options?.dryRun) {
+    for (const patch of matchingPatches) {
+      lockManager.removePatch(patch.id);
+    }
+    lockManager.save();
+  }
+  return { removed, notFound: false };
+}
+
+// src/commands/reset.ts
+import { unlinkSync } from "fs";
+function reset(outputDir, options) {
+  const lockManager = new LockfileManager(outputDir);
+  if (!lockManager.exists()) {
+    return {
+      success: true,
+      patchesRemoved: 0,
+      lockfileDeleted: false,
+      nothingToReset: true
+    };
+  }
+  const lock = lockManager.read();
+  const patchCount = lock.patches.length;
+  if (!options?.dryRun) {
+    unlinkSync(lockManager.lockfilePath);
+  }
+  return {
+    success: true,
+    patchesRemoved: patchCount,
+    lockfileDeleted: true,
+    nothingToReset: false
+  };
+}
+
+// src/commands/resolve.ts
+init_GitClient();
+async function resolve(outputDir, options) {
+  const lockManager = new LockfileManager(outputDir);
+  if (!lockManager.exists()) {
+    return { success: false, reason: "no-lockfile" };
+  }
+  const lock = lockManager.read();
+  if (lock.patches.length === 0) {
+    return { success: false, reason: "no-patches" };
+  }
+  const git = new GitClient(outputDir);
+  if (options?.checkMarkers !== false) {
+    const markerFiles = await git.exec(["grep", "-l", "<<<<<<<", "--", "."]).catch(() => "");
+    if (markerFiles.trim()) {
+      const files = markerFiles.trim().split("\n").filter(Boolean);
+      return { success: false, reason: "unresolved-conflicts", unresolvedFiles: files };
+    }
+  }
+  const committer = new ReplayCommitter(git, outputDir);
+  await committer.stageAll();
+  const commitSha = await committer.commitReplay(lock.patches.length, lock.patches);
+  return { success: true, commitSha };
+}
+
+// src/commands/status.ts
+function status(outputDir) {
+  const lockManager = new LockfileManager(outputDir);
+  if (!lockManager.exists()) {
+    return { initialized: false, patches: [], lastGeneration: void 0 };
+  }
+  const lock = lockManager.read();
+  const patches = lock.patches.map((patch) => ({
+    sha: patch.original_commit.slice(0, 7),
+    author: patch.original_author.split("<")[0]?.trim() ?? "unknown",
+    message: patch.original_message,
+    files: patch.files
+  }));
+  let lastGeneration;
+  const lastGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
+  if (lastGen) {
+    lastGeneration = {
+      sha: lastGen.commit_sha,
+      timestamp: lastGen.timestamp
+    };
+  }
+  return { initialized: true, patches, lastGeneration };
+}
+export {
+  FERN_BOT_EMAIL,
+  FERN_BOT_LOGIN,
+  FERN_BOT_NAME,
+  FernignoreMigrator,
+  GitClient,
+  LockfileManager,
+  ReplayApplicator,
+  ReplayCommitter,
+  ReplayDetector,
+  ReplayService,
+  bootstrap,
+  forget,
+  isGenerationCommit,
+  isReplayCommit,
+  reset,
+  resolve,
+  status,
+  threeWayMerge
+};
 //# sourceMappingURL=index.js.map