@fern-api/generator-cli 0.6.2 → 0.6.4

package/dist/cli.js

@@ -4867,18 +4867,18 @@ var require_build3 = __commonJS({
 var require_sync = __commonJS({
   "../../node_modules/.pnpm/escalade@3.2.0/node_modules/escalade/sync/index.js"(exports2, module2) {
     "use strict";
-    var { dirname: dirname6, resolve: resolve8 } = require("path");
+    var { dirname: dirname4, resolve: resolve8 } = require("path");
     var { readdirSync: readdirSync2, statSync: statSync4 } = require("fs");
     module2.exports = function(start, callback) {
       let dir = resolve8(".", start);
       let tmp3, stats = statSync4(dir);
       if (!stats.isDirectory()) {
-        dir = dirname6(dir);
+        dir = dirname4(dir);
       }
       while (true) {
         tmp3 = callback(dir, readdirSync2(dir));
         if (tmp3) return resolve8(dir, tmp3);
-        dir = dirname6(tmp3 = dir);
+        dir = dirname4(tmp3 = dir);
         if (tmp3 === dir) break;
       }
     };
@@ -4914,9 +4914,9 @@ var require_require_directory = __commonJS({
   "../../node_modules/.pnpm/require-directory@2.1.1/node_modules/require-directory/index.js"(exports2, module2) {
     "use strict";
     var fs3 = require("fs");
-    var join11 = require("path").join;
+    var join9 = require("path").join;
     var resolve8 = require("path").resolve;
-    var dirname6 = require("path").dirname;
+    var dirname4 = require("path").dirname;
     var defaultOptions2 = {
       extensions: ["js", "json", "coffee"],
       recurse: true,
@@ -4949,9 +4949,9 @@ var require_require_directory = __commonJS({
           options[prop] = defaultOptions2[prop];
         }
       }
-      path5 = !path5 ? dirname6(m.filename) : resolve8(dirname6(m.filename), path5);
+      path5 = !path5 ? dirname4(m.filename) : resolve8(dirname4(m.filename), path5);
       fs3.readdirSync(path5).forEach(function(filename) {
-        var joined = join11(path5, filename), files, key, obj;
+        var joined = join9(path5, filename), files, key, obj;
         if (fs3.statSync(joined).isDirectory() && options.recurse) {
           files = requireDirectory(m, joined, options);
           if (Object.keys(files).length) {
@@ -6604,7 +6604,7 @@ var require_ms = __commonJS({
       options = options || {};
       var type = typeof val;
       if (type === "string" && val.length > 0) {
-        return parse4(val);
+        return parse3(val);
       } else if (type === "number" && isFinite(val)) {
         return options.long ? fmtLong(val) : fmtShort(val);
       }
@@ -6612,7 +6612,7 @@ var require_ms = __commonJS({
         "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
       );
     };
-    function parse4(str) {
+    function parse3(str) {
       str = String(str);
       if (str.length > 100) {
         return;
@@ -7387,11 +7387,11 @@ var require_src2 = __commonJS({
 var require_dist = __commonJS({
   "../../node_modules/.pnpm/@kwsites+file-exists@1.1.1/node_modules/@kwsites/file-exists/dist/index.js"(exports2) {
     "use strict";
-    function __export3(m) {
+    function __export4(m) {
       for (var p in m) if (!exports2.hasOwnProperty(p)) exports2[p] = m[p];
     }
     Object.defineProperty(exports2, "__esModule", { value: true });
-    __export3(require_src2());
+    __export4(require_src2());
   }
 });
 
@@ -7654,7 +7654,7 @@ function parseStringResponse(result, parsers12, texts, trim = true) {
         }
         return lines[i + offset];
       };
-      parsers12.some(({ parse: parse4 }) => parse4(line, result));
+      parsers12.some(({ parse: parse3 }) => parse3(line, result));
     }
   });
   return result;
@@ -11898,7 +11898,7 @@ var require_fast_content_type_parse = __commonJS({
     var defaultContentType = { type: "", parameters: new NullObject() };
     Object.freeze(defaultContentType.parameters);
     Object.freeze(defaultContentType);
-    function parse4(header) {
+    function parse3(header) {
       if (typeof header !== "string") {
         throw new TypeError("argument header is required and must be a string");
       }
@@ -11974,148 +11974,13 @@ var require_fast_content_type_parse = __commonJS({
       }
       return result;
     }
-    module2.exports.default = { parse: parse4, safeParse: safeParse2 };
-    module2.exports.parse = parse4;
+    module2.exports.default = { parse: parse3, safeParse: safeParse2 };
+    module2.exports.parse = parse3;
     module2.exports.safeParse = safeParse2;
     module2.exports.defaultContentType = defaultContentType;
   }
 });
 
-// ../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/git/GitClient.js
-var GitClient_exports = {};
-__export(GitClient_exports, {
-  GitClient: () => GitClient
-});
-var GitClient;
-var init_GitClient = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/git/GitClient.js"() {
-    "use strict";
-    init_esm4();
-    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: spawn2 } = await import("child_process");
-        return new Promise((resolve8, reject) => {
-          const proc = spawn2("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) {
-              resolve8(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 format3 = "%H%x00%an%x00%ae%x00%s";
-        const output = await this.exec(["log", "-1", `--format=${format3}`, 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;
-      }
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/git/CommitDetection.js
-function isGenerationCommit(commit) {
-  const isFernSupport = FERN_SUPPORT_NAMES.includes(commit.authorName);
-  const isBotAuthor = !isFernSupport && (commit.authorLogin === FERN_BOT_LOGIN2 || commit.authorEmail === FERN_BOT_EMAIL2 || commit.authorName === FERN_BOT_NAME2);
-  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]");
-}
-var FERN_BOT_NAME2, FERN_BOT_EMAIL2, FERN_BOT_LOGIN2, FERN_SUPPORT_NAMES;
-var init_CommitDetection = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/git/CommitDetection.js"() {
-    "use strict";
-    FERN_BOT_NAME2 = "fern-api";
-    FERN_BOT_EMAIL2 = "115122769+fern-api[bot]@users.noreply.github.com";
-    FERN_BOT_LOGIN2 = "fern-api[bot]";
-    FERN_SUPPORT_NAMES = ["fern-support", "Fern Support"];
-  }
-});
-
 // ../../node_modules/.pnpm/yaml@2.3.3/node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS({
   "../../node_modules/.pnpm/yaml@2.3.3/node_modules/yaml/dist/nodes/identity.js"(exports2) {
@@ -19145,7 +19010,7 @@ var require_public_api = __commonJS({
       }
       return doc;
     }
-    function parse4(src, reviver, options) {
+    function parse3(src, reviver, options) {
       let _reviver = void 0;
       if (typeof reviver === "function") {
         _reviver = reviver;
@@ -19184,7 +19049,7 @@ var require_public_api = __commonJS({
       }
       return new Document.Document(value, _replacer, options).toString(options);
     }
-    exports2.parse = parse4;
+    exports2.parse = parse3;
     exports2.parseAllDocuments = parseAllDocuments;
     exports2.parseDocument = parseDocument;
     exports2.stringify = stringify3;
@@ -19243,485 +19108,259 @@ var require_dist3 = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/LockfileManager.js
-var import_node_fs, import_node_path2, import_yaml, LOCKFILE_HEADER, LockfileManager;
-var init_LockfileManager = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/LockfileManager.js"() {
-    "use strict";
-    import_node_fs = require("fs");
-    import_node_path2 = require("path");
-    import_yaml = __toESM(require_dist3(), 1);
-    LOCKFILE_HEADER = "# DO NOT EDIT MANUALLY - Managed by Fern Replay\n";
-    LockfileManager = class {
-      outputDir;
-      lock = null;
-      constructor(outputDir) {
-        this.outputDir = outputDir;
-      }
-      get lockfilePath() {
-        return (0, import_node_path2.join)(this.outputDir, ".fern", "replay.lock");
-      }
-      get customizationsPath() {
-        return (0, import_node_path2.join)(this.outputDir, ".fern", "replay.yml");
-      }
-      exists() {
-        return (0, import_node_fs.existsSync)(this.lockfilePath);
-      }
-      read() {
-        if (this.lock) {
-          return this.lock;
-        }
-        if (!this.exists()) {
-          throw new Error(`Lockfile not found: ${this.lockfilePath}`);
+// ../../node_modules/.pnpm/node-diff3@3.2.0/node_modules/node-diff3/dist/diff3.mjs
+function LCS(buffer1, buffer2) {
+  let equivalenceClasses = {};
+  for (let j = 0; j < buffer2.length; j++) {
+    const item = buffer2[j];
+    if (equivalenceClasses[item]) {
+      equivalenceClasses[item].push(j);
+    } else {
+      equivalenceClasses[item] = [j];
+    }
+  }
+  const NULLRESULT = { buffer1index: -1, buffer2index: -1, chain: null };
+  let candidates = [NULLRESULT];
+  for (let i = 0; i < buffer1.length; i++) {
+    const item = buffer1[i];
+    const buffer2indices = equivalenceClasses[item] || [];
+    let r = 0;
+    let c = candidates[0];
+    for (let jx = 0; jx < buffer2indices.length; jx++) {
+      const j = buffer2indices[jx];
+      let s;
+      for (s = r; s < candidates.length; s++) {
+        if (candidates[s].buffer2index < j && (s === candidates.length - 1 || candidates[s + 1].buffer2index > j)) {
+          break;
         }
-        const content = (0, import_node_fs.readFileSync)(this.lockfilePath, "utf-8");
-        this.lock = (0, import_yaml.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.");
+      if (s < candidates.length) {
+        const newCandidate = { buffer1index: i, buffer2index: j, chain: candidates[s] };
+        if (r === candidates.length) {
+          candidates.push(c);
+        } else {
+          candidates[r] = c;
         }
-        const dir = (0, import_node_path2.dirname)(this.lockfilePath);
-        if (!(0, import_node_fs.existsSync)(dir)) {
-          (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+        r = s + 1;
+        c = newCandidate;
+        if (r === candidates.length) {
+          break;
         }
-        const yaml = (0, import_yaml.stringify)(this.lock, {
-          lineWidth: 0,
-          blockQuote: "literal"
-        });
-        const content = LOCKFILE_HEADER + yaml;
-        const tmpPath = this.lockfilePath + ".tmp";
-        (0, import_node_fs.writeFileSync)(tmpPath, content, "utf-8");
-        (0, import_node_fs.renameSync)(tmpPath, this.lockfilePath);
       }
-      addGeneration(record2) {
-        this.ensureLoaded();
-        this.lock.generations.push(record2);
-        this.lock.current_generation = record2.commit_sha;
+    }
+    candidates[r] = c;
+  }
+  return candidates[candidates.length - 1];
+}
+function diffIndices(buffer1, buffer2) {
+  const lcs = LCS(buffer1, buffer2);
+  let result = [];
+  let tail1 = buffer1.length;
+  let tail2 = buffer2.length;
+  for (let candidate = lcs; candidate !== null; candidate = candidate.chain) {
+    const mismatchLength1 = tail1 - candidate.buffer1index - 1;
+    const mismatchLength2 = tail2 - candidate.buffer2index - 1;
+    tail1 = candidate.buffer1index;
+    tail2 = candidate.buffer2index;
+    if (mismatchLength1 || mismatchLength2) {
+      result.push({
+        buffer1: [tail1 + 1, mismatchLength1],
+        buffer1Content: buffer1.slice(tail1 + 1, tail1 + 1 + mismatchLength1),
+        buffer2: [tail2 + 1, mismatchLength2],
+        buffer2Content: buffer2.slice(tail2 + 1, tail2 + 1 + mismatchLength2)
+      });
+    }
+  }
+  result.reverse();
+  return result;
+}
+function diff3MergeRegions(a, o, b) {
+  let hunks = [];
+  function addHunk(h, ab) {
+    hunks.push({
+      ab,
+      oStart: h.buffer1[0],
+      oLength: h.buffer1[1],
+      abStart: h.buffer2[0],
+      abLength: h.buffer2[1]
+    });
+  }
+  diffIndices(o, a).forEach((item) => addHunk(item, "a"));
+  diffIndices(o, b).forEach((item) => addHunk(item, "b"));
+  hunks.sort((x, y) => x.oStart - y.oStart);
+  let results = [];
+  let currOffset = 0;
+  function advanceTo(endOffset) {
+    if (endOffset > currOffset) {
+      results.push({
+        stable: true,
+        buffer: "o",
+        bufferStart: currOffset,
+        bufferLength: endOffset - currOffset,
+        bufferContent: o.slice(currOffset, endOffset)
+      });
+      currOffset = endOffset;
+    }
+  }
+  while (hunks.length) {
+    let hunk = hunks.shift();
+    let regionStart = hunk.oStart;
+    let regionEnd = hunk.oStart + hunk.oLength;
+    let regionHunks = [hunk];
+    advanceTo(regionStart);
+    while (hunks.length) {
+      const nextHunk = hunks[0];
+      const nextHunkStart = nextHunk.oStart;
+      if (nextHunkStart > regionEnd)
+        break;
+      regionEnd = Math.max(regionEnd, nextHunkStart + nextHunk.oLength);
+      regionHunks.push(hunks.shift());
+    }
+    if (regionHunks.length === 1) {
+      if (hunk.abLength > 0) {
+        const buffer = hunk.ab === "a" ? a : b;
+        results.push({
+          stable: true,
+          buffer: hunk.ab,
+          bufferStart: hunk.abStart,
+          bufferLength: hunk.abLength,
+          bufferContent: buffer.slice(hunk.abStart, hunk.abStart + hunk.abLength)
+        });
       }
-      addPatch(patch) {
-        this.ensureLoaded();
-        this.lock.patches.push(patch);
+    } else {
+      let bounds = {
+        a: [a.length, -1, o.length, -1],
+        b: [b.length, -1, o.length, -1]
+      };
+      while (regionHunks.length) {
+        hunk = regionHunks.shift();
+        const oStart = hunk.oStart;
+        const oEnd = oStart + hunk.oLength;
+        const abStart = hunk.abStart;
+        const abEnd = abStart + hunk.abLength;
+        let b2 = bounds[hunk.ab];
+        b2[0] = Math.min(abStart, b2[0]);
+        b2[1] = Math.max(abEnd, b2[1]);
+        b2[2] = Math.min(oStart, b2[2]);
+        b2[3] = Math.max(oEnd, b2[3]);
       }
-      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 (!(0, import_node_fs.existsSync)(this.customizationsPath)) {
-          return {};
-        }
-        const content = (0, import_node_fs.readFileSync)(this.customizationsPath, "utf-8");
-        return (0, import_yaml.parse)(content) ?? {};
-      }
-      ensureLoaded() {
-        if (!this.lock) {
-          throw new Error("No lockfile loaded. Call read() or initialize() first.");
-        }
-      }
-    };
+      const aStart = bounds.a[0] + (regionStart - bounds.a[2]);
+      const aEnd = bounds.a[1] + (regionEnd - bounds.a[3]);
+      const bStart = bounds.b[0] + (regionStart - bounds.b[2]);
+      const bEnd = bounds.b[1] + (regionEnd - bounds.b[3]);
+      let result = {
+        stable: false,
+        aStart,
+        aLength: aEnd - aStart,
+        aContent: a.slice(aStart, aEnd),
+        oStart: regionStart,
+        oLength: regionEnd - regionStart,
+        oContent: o.slice(regionStart, regionEnd),
+        bStart,
+        bLength: bEnd - bStart,
+        bContent: b.slice(bStart, bEnd)
+      };
+      results.push(result);
+    }
+    currOffset = regionEnd;
   }
-});
-
-// ../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/ReplayDetector.js
-var import_node_crypto, INFRASTRUCTURE_FILES, ReplayDetector;
-var init_ReplayDetector = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/ReplayDetector.js"() {
-    "use strict";
-    import_node_crypto = require("crypto");
-    init_CommitDetection();
-    INFRASTRUCTURE_FILES = /* @__PURE__ */ new Set([".fernignore"]);
-    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 exists2 = await this.git.commitExists(lastGen.commit_sha);
-        if (!exists2) {
-          this.warnings.push(`Generation commit ${lastGen.commit_sha.slice(0, 7)} not found in git history. 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:${(0, import_node_crypto.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
+  advanceTo(o.length);
+  return results;
+}
+function diff3Merge(a, o, b, options) {
+  let defaults3 = {
+    excludeFalseConflicts: true,
+    stringSeparator: /\s+/
+  };
+  options = Object.assign(defaults3, options);
+  if (typeof a === "string")
+    a = a.split(options.stringSeparator);
+  if (typeof o === "string")
+    o = o.split(options.stringSeparator);
+  if (typeof b === "string")
+    b = b.split(options.stringSeparator);
+  let results = [];
+  const regions = diff3MergeRegions(a, o, b);
+  let okBuffer = [];
+  function flushOk() {
+    if (okBuffer.length) {
+      results.push({ ok: okBuffer });
+    }
+    okBuffer = [];
+  }
+  function isFalseConflict(a2, b2) {
+    if (a2.length !== b2.length)
+      return false;
+    for (let i = 0; i < a2.length; i++) {
+      if (a2[i] !== b2[i])
+        return false;
+    }
+    return true;
+  }
+  regions.forEach((region) => {
+    if (region.stable) {
+      okBuffer.push(...region.bufferContent);
+    } else {
+      if (options.excludeFalseConflicts && isFalseConflict(region.aContent, region.bContent)) {
+        okBuffer.push(...region.aContent);
+      } else {
+        flushOk();
+        results.push({
+          conflict: {
+            a: region.aContent,
+            aIndex: region.aStart,
+            o: region.oContent,
+            oIndex: region.oStart,
+            b: region.bContent,
+            bIndex: region.bStart
           }
-        ];
-      }
-      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);
-      }
-    };
+    }
+  });
+  flushOk();
+  return results;
+}
+var init_diff3 = __esm({
+  "../../node_modules/.pnpm/node-diff3@3.2.0/node_modules/node-diff3/dist/diff3.mjs"() {
+    "use strict";
   }
 });
 
-// ../../node_modules/.pnpm/node-diff3@3.2.0/node_modules/node-diff3/dist/diff3.mjs
-function LCS(buffer1, buffer2) {
-  let equivalenceClasses = {};
-  for (let j = 0; j < buffer2.length; j++) {
-    const item = buffer2[j];
-    if (equivalenceClasses[item]) {
-      equivalenceClasses[item].push(j);
-    } else {
-      equivalenceClasses[item] = [j];
-    }
-  }
-  const NULLRESULT = { buffer1index: -1, buffer2index: -1, chain: null };
-  let candidates = [NULLRESULT];
-  for (let i = 0; i < buffer1.length; i++) {
-    const item = buffer1[i];
-    const buffer2indices = equivalenceClasses[item] || [];
-    let r = 0;
-    let c = candidates[0];
-    for (let jx = 0; jx < buffer2indices.length; jx++) {
-      const j = buffer2indices[jx];
-      let s;
-      for (s = r; s < candidates.length; s++) {
-        if (candidates[s].buffer2index < j && (s === candidates.length - 1 || candidates[s + 1].buffer2index > j)) {
-          break;
-        }
-      }
-      if (s < candidates.length) {
-        const newCandidate = { buffer1index: i, buffer2index: j, chain: candidates[s] };
-        if (r === candidates.length) {
-          candidates.push(c);
-        } else {
-          candidates[r] = c;
-        }
-        r = s + 1;
-        c = newCandidate;
-        if (r === candidates.length) {
-          break;
-        }
-      }
-    }
-    candidates[r] = c;
-  }
-  return candidates[candidates.length - 1];
-}
-function diffIndices(buffer1, buffer2) {
-  const lcs = LCS(buffer1, buffer2);
-  let result = [];
-  let tail1 = buffer1.length;
-  let tail2 = buffer2.length;
-  for (let candidate = lcs; candidate !== null; candidate = candidate.chain) {
-    const mismatchLength1 = tail1 - candidate.buffer1index - 1;
-    const mismatchLength2 = tail2 - candidate.buffer2index - 1;
-    tail1 = candidate.buffer1index;
-    tail2 = candidate.buffer2index;
-    if (mismatchLength1 || mismatchLength2) {
-      result.push({
-        buffer1: [tail1 + 1, mismatchLength1],
-        buffer1Content: buffer1.slice(tail1 + 1, tail1 + 1 + mismatchLength1),
-        buffer2: [tail2 + 1, mismatchLength2],
-        buffer2Content: buffer2.slice(tail2 + 1, tail2 + 1 + mismatchLength2)
-      });
-    }
-  }
-  result.reverse();
-  return result;
-}
-function diff3MergeRegions(a, o, b) {
-  let hunks = [];
-  function addHunk(h, ab) {
-    hunks.push({
-      ab,
-      oStart: h.buffer1[0],
-      oLength: h.buffer1[1],
-      abStart: h.buffer2[0],
-      abLength: h.buffer2[1]
-    });
-  }
-  diffIndices(o, a).forEach((item) => addHunk(item, "a"));
-  diffIndices(o, b).forEach((item) => addHunk(item, "b"));
-  hunks.sort((x, y) => x.oStart - y.oStart);
-  let results = [];
-  let currOffset = 0;
-  function advanceTo(endOffset) {
-    if (endOffset > currOffset) {
-      results.push({
-        stable: true,
-        buffer: "o",
-        bufferStart: currOffset,
-        bufferLength: endOffset - currOffset,
-        bufferContent: o.slice(currOffset, endOffset)
-      });
-      currOffset = endOffset;
-    }
-  }
-  while (hunks.length) {
-    let hunk = hunks.shift();
-    let regionStart = hunk.oStart;
-    let regionEnd = hunk.oStart + hunk.oLength;
-    let regionHunks = [hunk];
-    advanceTo(regionStart);
-    while (hunks.length) {
-      const nextHunk = hunks[0];
-      const nextHunkStart = nextHunk.oStart;
-      if (nextHunkStart > regionEnd)
-        break;
-      regionEnd = Math.max(regionEnd, nextHunkStart + nextHunk.oLength);
-      regionHunks.push(hunks.shift());
-    }
-    if (regionHunks.length === 1) {
-      if (hunk.abLength > 0) {
-        const buffer = hunk.ab === "a" ? a : b;
-        results.push({
-          stable: true,
-          buffer: hunk.ab,
-          bufferStart: hunk.abStart,
-          bufferLength: hunk.abLength,
-          bufferContent: buffer.slice(hunk.abStart, hunk.abStart + hunk.abLength)
-        });
-      }
-    } else {
-      let bounds = {
-        a: [a.length, -1, o.length, -1],
-        b: [b.length, -1, o.length, -1]
-      };
-      while (regionHunks.length) {
-        hunk = regionHunks.shift();
-        const oStart = hunk.oStart;
-        const oEnd = oStart + hunk.oLength;
-        const abStart = hunk.abStart;
-        const abEnd = abStart + hunk.abLength;
-        let b2 = bounds[hunk.ab];
-        b2[0] = Math.min(abStart, b2[0]);
-        b2[1] = Math.max(abEnd, b2[1]);
-        b2[2] = Math.min(oStart, b2[2]);
-        b2[3] = Math.max(oEnd, b2[3]);
-      }
-      const aStart = bounds.a[0] + (regionStart - bounds.a[2]);
-      const aEnd = bounds.a[1] + (regionEnd - bounds.a[3]);
-      const bStart = bounds.b[0] + (regionStart - bounds.b[2]);
-      const bEnd = bounds.b[1] + (regionEnd - bounds.b[3]);
-      let result = {
-        stable: false,
-        aStart,
-        aLength: aEnd - aStart,
-        aContent: a.slice(aStart, aEnd),
-        oStart: regionStart,
-        oLength: regionEnd - regionStart,
-        oContent: o.slice(regionStart, regionEnd),
-        bStart,
-        bLength: bEnd - bStart,
-        bContent: b.slice(bStart, bEnd)
-      };
-      results.push(result);
-    }
-    currOffset = regionEnd;
-  }
-  advanceTo(o.length);
-  return results;
+// ../../node_modules/.pnpm/@fern-api+replay@0.6.1/node_modules/@fern-api/replay/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  FERN_BOT_EMAIL: () => FERN_BOT_EMAIL2,
+  FERN_BOT_LOGIN: () => FERN_BOT_LOGIN2,
+  FERN_BOT_NAME: () => FERN_BOT_NAME2,
+  FernignoreMigrator: () => FernignoreMigrator,
+  GitClient: () => GitClient,
+  LockfileManager: () => LockfileManager,
+  ReplayApplicator: () => ReplayApplicator,
+  ReplayCommitter: () => ReplayCommitter,
+  ReplayDetector: () => ReplayDetector,
+  ReplayService: () => ReplayService,
+  bootstrap: () => bootstrap,
+  forget: () => forget,
+  isGenerationCommit: () => isGenerationCommit,
+  isReplayCommit: () => isReplayCommit,
+  reset: () => reset,
+  resolve: () => resolve7,
+  status: () => status,
+  threeWayMerge: () => threeWayMerge
+});
+function isGenerationCommit(commit) {
+  const isFernSupport = FERN_SUPPORT_NAMES.includes(commit.authorName);
+  const isBotAuthor = !isFernSupport && (commit.authorLogin === FERN_BOT_LOGIN2 || commit.authorEmail === FERN_BOT_EMAIL2 || commit.authorName === FERN_BOT_NAME2);
+  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 diff3Merge(a, o, b, options) {
-  let defaults3 = {
-    excludeFalseConflicts: true,
-    stringSeparator: /\s+/
-  };
-  options = Object.assign(defaults3, options);
-  if (typeof a === "string")
-    a = a.split(options.stringSeparator);
-  if (typeof o === "string")
-    o = o.split(options.stringSeparator);
-  if (typeof b === "string")
-    b = b.split(options.stringSeparator);
-  let results = [];
-  const regions = diff3MergeRegions(a, o, b);
-  let okBuffer = [];
-  function flushOk() {
-    if (okBuffer.length) {
-      results.push({ ok: okBuffer });
-    }
-    okBuffer = [];
-  }
-  function isFalseConflict(a2, b2) {
-    if (a2.length !== b2.length)
-      return false;
-    for (let i = 0; i < a2.length; i++) {
-      if (a2[i] !== b2[i])
-        return false;
-    }
-    return true;
-  }
-  regions.forEach((region) => {
-    if (region.stable) {
-      okBuffer.push(...region.bufferContent);
-    } else {
-      if (options.excludeFalseConflicts && isFalseConflict(region.aContent, region.bContent)) {
-        okBuffer.push(...region.aContent);
-      } else {
-        flushOk();
-        results.push({
-          conflict: {
-            a: region.aContent,
-            aIndex: region.aStart,
-            o: region.oContent,
-            oIndex: region.oStart,
-            b: region.bContent,
-            bIndex: region.bStart
-          }
-        });
-      }
-    }
-  });
-  flushOk();
-  return results;
+function isReplayCommit(commit) {
+  return commit.message.startsWith("[fern-replay]");
 }
-var init_diff3 = __esm({
-  "../../node_modules/.pnpm/node-diff3@3.2.0/node_modules/node-diff3/dist/diff3.mjs"() {
-    "use strict";
-  }
-});
-
-// ../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/ThreeWayMerge.js
 function threeWayMerge(base, ours, theirs) {
   const baseLines = base.split("\n");
   const oursLines = ours.split("\n");
@@ -19757,54 +19396,702 @@ function threeWayMerge(base, ours, theirs) {
     conflicts: conflicts2
   };
 }
-var init_ThreeWayMerge = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/ThreeWayMerge.js"() {
-    "use strict";
-    init_diff3();
-  }
-});
-
-// ../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/ReplayApplicator.js
 function isBinaryFile(filePath) {
-  const ext2 = (0, import_node_path3.extname)(filePath).toLowerCase();
+  const ext2 = (0, import_path9.extname)(filePath).toLowerCase();
   return BINARY_EXTENSIONS.has(ext2);
 }
 function isDiffLineForFile(diffLine, filePath) {
   const match2 = diffLine.match(/^diff --git a\/.+ b\/(.+)$/);
   return match2 !== null && match2[1] === filePath;
 }
-var import_promises4, import_node_os, import_node_path3, BINARY_EXTENSIONS, ReplayApplicator;
-var init_ReplayApplicator = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/ReplayApplicator.js"() {
-    "use strict";
-    import_promises4 = require("fs/promises");
-    import_node_os = require("os");
-    import_node_path3 = require("path");
-    init_esm3();
-    init_ThreeWayMerge();
-    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",
+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 };
+  });
+}
+function ensureFernignoreEntries(outputDir) {
+  const fernignorePath = (0, import_path12.join)(outputDir, ".fernignore");
+  let content = "";
+  if ((0, import_fs9.existsSync)(fernignorePath)) {
+    content = (0, import_fs9.readFileSync)(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";
+  (0, import_fs9.writeFileSync)(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:${(0, import_crypto3.createHash)("sha256").update(normalized).digest("hex")}`;
+}
+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 || minimatch(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 };
+}
+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) {
+    (0, import_fs10.unlinkSync)(lockManager.lockfilePath);
+  }
+  return {
+    success: true,
+    patchesRemoved: patchCount,
+    lockfileDeleted: true,
+    nothingToReset: false
+  };
+}
+async function resolve7(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 };
+}
+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 };
+}
+var import_fs6, import_path8, import_yaml, import_crypto, import_promises4, import_os, import_path9, import_fs7, import_path10, import_crypto2, import_fs8, import_path11, import_yaml2, import_crypto3, import_fs9, import_path12, import_fs10, __defProp3, __getOwnPropNames3, __esm3, __export3, GitClient_exports, GitClient, init_GitClient, FERN_BOT_NAME2, FERN_BOT_EMAIL2, FERN_BOT_LOGIN2, FERN_SUPPORT_NAMES, LOCKFILE_HEADER, LockfileManager, INFRASTRUCTURE_FILES, ReplayDetector, BINARY_EXTENSIONS, ReplayApplicator, ReplayCommitter, ReplayService, FernignoreMigrator, REPLAY_FERNIGNORE_ENTRIES;
+var init_dist = __esm({
+  "../../node_modules/.pnpm/@fern-api+replay@0.6.1/node_modules/@fern-api/replay/dist/index.js"() {
+    "use strict";
+    init_esm4();
+    import_fs6 = require("fs");
+    import_path8 = require("path");
+    import_yaml = __toESM(require_dist3(), 1);
+    import_crypto = require("crypto");
+    init_diff3();
+    import_promises4 = require("fs/promises");
+    import_os = require("os");
+    import_path9 = require("path");
+    init_esm3();
+    import_fs7 = require("fs");
+    import_path10 = require("path");
+    init_esm3();
+    import_crypto2 = require("crypto");
+    import_fs8 = require("fs");
+    import_path11 = require("path");
+    init_esm3();
+    import_yaml2 = __toESM(require_dist3(), 1);
+    import_crypto3 = require("crypto");
+    import_fs9 = require("fs");
+    import_path12 = require("path");
+    init_esm3();
+    import_fs10 = require("fs");
+    __defProp3 = Object.defineProperty;
+    __getOwnPropNames3 = Object.getOwnPropertyNames;
+    __esm3 = (fn, res) => function __init() {
+      return fn && (res = (0, fn[__getOwnPropNames3(fn)[0]])(fn = 0)), res;
+    };
+    __export3 = (target, all) => {
+      for (var name in all)
+        __defProp3(target, name, { get: all[name], enumerable: true });
+    };
+    GitClient_exports = {};
+    __export3(GitClient_exports, {
+      GitClient: () => GitClient
+    });
+    init_GitClient = __esm3({
+      "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: spawn2 } = await import("child_process");
+            return new Promise((resolve22, reject) => {
+              const proc = spawn2("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) {
+                  resolve22(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 format3 = "%H%x00%an%x00%ae%x00%s";
+            const output = await this.exec(["log", "-1", `--format=${format3}`, 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;
+          }
+        };
+      }
+    });
+    init_GitClient();
+    FERN_BOT_NAME2 = "fern-api";
+    FERN_BOT_EMAIL2 = "115122769+fern-api[bot]@users.noreply.github.com";
+    FERN_BOT_LOGIN2 = "fern-api[bot]";
+    FERN_SUPPORT_NAMES = ["fern-support", "Fern Support"];
+    LOCKFILE_HEADER = "# DO NOT EDIT MANUALLY - Managed by Fern Replay\n";
+    LockfileManager = class {
+      outputDir;
+      lock = null;
+      constructor(outputDir) {
+        this.outputDir = outputDir;
+      }
+      get lockfilePath() {
+        return (0, import_path8.join)(this.outputDir, ".fern", "replay.lock");
+      }
+      get customizationsPath() {
+        return (0, import_path8.join)(this.outputDir, ".fern", "replay.yml");
+      }
+      exists() {
+        return (0, import_fs6.existsSync)(this.lockfilePath);
+      }
+      read() {
+        if (this.lock) {
+          return this.lock;
+        }
+        if (!this.exists()) {
+          throw new Error(`Lockfile not found: ${this.lockfilePath}`);
+        }
+        const content = (0, import_fs6.readFileSync)(this.lockfilePath, "utf-8");
+        this.lock = (0, import_yaml.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 = (0, import_path8.dirname)(this.lockfilePath);
+        if (!(0, import_fs6.existsSync)(dir)) {
+          (0, import_fs6.mkdirSync)(dir, { recursive: true });
+        }
+        const yaml = (0, import_yaml.stringify)(this.lock, {
+          lineWidth: 0,
+          blockQuote: "literal"
+        });
+        const content = LOCKFILE_HEADER + yaml;
+        const tmpPath = this.lockfilePath + ".tmp";
+        (0, import_fs6.writeFileSync)(tmpPath, content, "utf-8");
+        (0, import_fs6.renameSync)(tmpPath, this.lockfilePath);
+      }
+      addGeneration(record2) {
+        this.ensureLoaded();
+        this.lock.generations.push(record2);
+        this.lock.current_generation = record2.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 (!(0, import_fs6.existsSync)(this.customizationsPath)) {
+          return {};
+        }
+        const content = (0, import_fs6.readFileSync)(this.customizationsPath, "utf-8");
+        return (0, import_yaml.parse)(content) ?? {};
+      }
+      ensureLoaded() {
+        if (!this.lock) {
+          throw new Error("No lockfile loaded. Call read() or initialize() first.");
+        }
+      }
+    };
+    INFRASTRUCTURE_FILES = /* @__PURE__ */ new Set([".fernignore"]);
+    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 exists2 = await this.git.commitExists(lastGen.commit_sha);
+        if (!exists2) {
+          this.warnings.push(
+            `Generation commit ${lastGen.commit_sha.slice(0, 7)} not found in git history. 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:${(0, import_crypto.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);
+      }
+    };
+    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",
@@ -19869,9 +20156,8 @@ var init_ReplayApplicator = __esm({
       }
       /** Populate accumulator after git apply succeeds. */
       async populateAccumulatorForPatch(patch, baseGen, currentTreeHash) {
-        if (!baseGen)
-          return;
-        const tempDir = await (0, import_promises4.mkdtemp)((0, import_node_path3.join)((0, import_node_os.tmpdir)(), "replay-acc-"));
+        if (!baseGen) return;
+        const tempDir = await (0, import_promises4.mkdtemp)((0, import_path9.join)((0, import_os.tmpdir)(), "replay-acc-"));
         const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
         const tempGit = new GitClient2(tempDir);
         await tempGit.exec(["init"]);
@@ -19879,8 +20165,7 @@ var init_ReplayApplicator = __esm({
         await tempGit.exec(["config", "user.name", "Fern Replay"]);
         try {
           for (const filePath of patch.files) {
-            if (isBinaryFile(filePath))
-              continue;
+            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);
@@ -19901,12 +20186,13 @@ var init_ReplayApplicator = __esm({
         const lock = this.lockManager.read();
         const currentGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
         const currentTreeHash = currentGen?.tree_hash ?? baseGen?.tree_hash ?? "";
-        const needsAccumulation = await Promise.all(patch.files.map(async (f) => {
-          if (!baseGen)
-            return false;
-          const resolved = await this.resolveFilePath(f, baseGen.tree_hash, currentTreeHash);
-          return this.fileTheirsAccumulator.has(resolved);
-        })).then((results) => results.some(Boolean));
+        const 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 = {};
@@ -19915,7 +20201,7 @@ var init_ReplayApplicator = __esm({
             if (resolvedPath !== filePath) {
               resolvedFiles[filePath] = resolvedPath;
             }
-            const fullPath = (0, import_node_path3.join)(this.outputDir, resolvedPath);
+            const fullPath = (0, import_path9.join)(this.outputDir, resolvedPath);
             snapshots.set(resolvedPath, await (0, import_promises4.readFile)(fullPath, "utf-8").catch(() => null));
           }
           try {
@@ -19930,7 +20216,7 @@ var init_ReplayApplicator = __esm({
           } catch {
             for (const [resolvedPath, content] of snapshots) {
               if (content != null) {
-                await (0, import_promises4.writeFile)((0, import_node_path3.join)(this.outputDir, resolvedPath), content);
+                await (0, import_promises4.writeFile)((0, import_path9.join)(this.outputDir, resolvedPath), content);
               }
             }
           }
@@ -19940,7 +20226,7 @@ var init_ReplayApplicator = __esm({
       async applyWithThreeWayMerge(patch) {
         const fileResults = [];
         const resolvedFiles = {};
-        const tempDir = await (0, import_promises4.mkdtemp)((0, import_node_path3.join)((0, import_node_os.tmpdir)(), "replay-"));
+        const tempDir = await (0, import_promises4.mkdtemp)((0, import_path9.join)((0, import_os.tmpdir)(), "replay-"));
         const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
         const tempGit = new GitClient2(tempDir);
         await tempGit.exec(["init"]);
@@ -20003,13 +20289,26 @@ var init_ReplayApplicator = __esm({
               renameSourcePath = renameSource;
             }
           }
-          const oursPath = (0, import_node_path3.join)(this.outputDir, resolvedPath);
+          const oursPath = (0, import_path9.join)(this.outputDir, resolvedPath);
           const ours = await (0, import_promises4.readFile)(oursPath, "utf-8").catch(() => null);
-          let theirs = await this.applyPatchToContent(base, patch.patch_content, filePath, tempGit, tempDir, renameSourcePath);
+          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);
+            theirs = await this.applyPatchToContent(
+              accumulatorEntry.content,
+              patch.patch_content,
+              filePath,
+              tempGit,
+              tempDir
+            );
             if (theirs) {
               useAccumulatorAsMergeBase = true;
             }
@@ -20033,14 +20332,14 @@ var init_ReplayApplicator = __esm({
             }
           }
           if (!base && !ours && effective_theirs) {
-            const outDir2 = (0, import_node_path3.dirname)(oursPath);
+            const outDir2 = (0, import_path9.dirname)(oursPath);
             await (0, import_promises4.mkdir)(outDir2, { recursive: true });
             await (0, import_promises4.writeFile)(oursPath, effective_theirs);
             return { file: resolvedPath, status: "merged", reason: "new-file" };
           }
           if (!base && ours && effective_theirs) {
             const merged2 = threeWayMerge("", ours, effective_theirs);
-            const outDir2 = (0, import_node_path3.dirname)(oursPath);
+            const outDir2 = (0, import_path9.dirname)(oursPath);
             await (0, import_promises4.mkdir)(outDir2, { recursive: true });
             await (0, import_promises4.writeFile)(oursPath, merged2.content);
             if (merged2.hasConflicts) {
@@ -20070,7 +20369,7 @@ var init_ReplayApplicator = __esm({
           }
           const mergeBase = useAccumulatorAsMergeBase && accumulatorEntry ? accumulatorEntry.content : base;
           const merged = threeWayMerge(mergeBase, ours, effective_theirs);
-          const outDir = (0, import_node_path3.dirname)(oursPath);
+          const outDir = (0, import_path9.dirname)(oursPath);
           await (0, import_promises4.mkdir)(outDir, { recursive: true });
           await (0, import_promises4.writeFile)(oursPath, merged.content);
           if (effective_theirs && base) {
@@ -20099,8 +20398,7 @@ var init_ReplayApplicator = __esm({
       }
       isExcluded(patch) {
         const config = this.lockManager.getCustomizationsConfig();
-        if (!config.exclude)
-          return false;
+        if (!config.exclude) return false;
         return patch.files.some((file) => config.exclude.some((pattern) => minimatch(file, pattern)));
       }
       async resolveFilePath(filePath, baseTreeHash, currentTreeHash) {
@@ -20136,12 +20434,11 @@ var init_ReplayApplicator = __esm({
           return this.extractNewFileFromPatch(patchContent, filePath);
         }
         const fileDiff = this.extractFileDiff(patchContent, filePath);
-        if (!fileDiff)
-          return null;
+        if (!fileDiff) return null;
         try {
           if (sourceFilePath) {
-            const tempSourcePath = (0, import_node_path3.join)(tempDir, sourceFilePath);
-            await (0, import_promises4.mkdir)((0, import_node_path3.dirname)(tempSourcePath), { recursive: true });
+            const tempSourcePath = (0, import_path9.join)(tempDir, sourceFilePath);
+            await (0, import_promises4.mkdir)((0, import_path9.dirname)(tempSourcePath), { recursive: true });
             await (0, import_promises4.writeFile)(tempSourcePath, base);
             await tempGit.exec(["add", sourceFilePath]);
             await tempGit.exec([
@@ -20151,11 +20448,11 @@ var init_ReplayApplicator = __esm({
               "--allow-empty"
             ]);
             await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
-            const tempTargetPath = (0, import_node_path3.join)(tempDir, filePath);
+            const tempTargetPath = (0, import_path9.join)(tempDir, filePath);
             return await (0, import_promises4.readFile)(tempTargetPath, "utf-8");
           }
-          const tempFilePath = (0, import_node_path3.join)(tempDir, filePath);
-          await (0, import_promises4.mkdir)((0, import_node_path3.dirname)(tempFilePath), { recursive: true });
+          const tempFilePath = (0, import_path9.join)(tempDir, filePath);
+          await (0, import_promises4.mkdir)((0, import_path9.dirname)(tempFilePath), { recursive: true });
           await (0, import_promises4.writeFile)(tempFilePath, base);
           await tempGit.exec(["add", filePath]);
           await tempGit.exec(["commit", "-m", `base for ${filePath}`, "--allow-empty"]);
@@ -20191,15 +20488,12 @@ var init_ReplayApplicator = __esm({
         let inTargetFile = false;
         for (const line of lines) {
           if (line.startsWith("diff --git")) {
-            if (inTargetFile)
-              break;
+            if (inTargetFile) break;
             inTargetFile = isDiffLineForFile(line, targetFilePath);
             continue;
           }
-          if (!inTargetFile)
-            continue;
-          if (line.startsWith("@@"))
-            break;
+          if (!inTargetFile) continue;
+          if (line.startsWith("@@")) break;
           if (line.startsWith("rename from ")) {
             return line.slice("rename from ".length);
           }
@@ -20214,20 +20508,17 @@ var init_ReplayApplicator = __esm({
         let noTrailingNewline = false;
         for (const line of lines) {
           if (line.startsWith("diff --git")) {
-            if (inTargetFile)
-              break;
+            if (inTargetFile) break;
             inTargetFile = isDiffLineForFile(line, filePath);
             inHunk = false;
             continue;
           }
-          if (!inTargetFile)
-            continue;
+          if (!inTargetFile) continue;
           if (line.startsWith("@@")) {
             inHunk = true;
             continue;
           }
-          if (!inHunk)
-            continue;
+          if (!inHunk) continue;
           if (line === "\") {
             noTrailingNewline = true;
             continue;
@@ -20236,19 +20527,10 @@ var init_ReplayApplicator = __esm({
             addedLines.push(line.slice(1));
           }
         }
-        if (addedLines.length === 0)
-          return null;
+        if (addedLines.length === 0) return null;
         return addedLines.join("\n") + (noTrailingNewline ? "" : "\n");
       }
     };
-  }
-});
-
-// ../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/ReplayCommitter.js
-var ReplayCommitter;
-var init_ReplayCommitter = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/ReplayCommitter.js"() {
-    "use strict";
     ReplayCommitter = class {
       git;
       outputDir;
@@ -20317,22 +20599,7 @@ CLI Version: ${options.cliVersion}`;
         return this.git.getTreeHash(commitSha);
       }
     };
-  }
-});
-
-// ../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/ReplayService.js
-var import_node_fs2, import_node_path4, ReplayService;
-var init_ReplayService = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/ReplayService.js"() {
-    "use strict";
-    import_node_fs2 = require("fs");
-    import_node_path4 = require("path");
-    init_esm3();
     init_GitClient();
-    init_LockfileManager();
-    init_ReplayApplicator();
-    init_ReplayCommitter();
-    init_ReplayDetector();
     ReplayService = class {
       git;
       detector;
@@ -20578,7 +20845,15 @@ var init_ReplayService = __esm({
             await this.committer.commitReplay(appliedCount, allPatches);
           }
         }
-        return this.buildReport("normal-regeneration", allPatches, results, options, warnings, rebaseCounts, preRebaseCounts);
+        return this.buildReport(
+          "normal-regeneration",
+          allPatches,
+          results,
+          options,
+          warnings,
+          rebaseCounts,
+          preRebaseCounts
+        );
       }
       /**
        * Rebase cleanly applied patches so they are relative to the current generation.
@@ -20608,23 +20883,23 @@ var init_ReplayService = __esm({
             await this.trimAbsorbedFiles(result, currentGenSha);
             continue;
           }
-          if (result.status !== "applied")
-            continue;
+          if (result.status !== "applied") continue;
           const patch = result.patch;
-          if (patch.base_generation === currentGenSha)
-            continue;
+          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 || minimatch(file, p))) {
-                return true;
-              }
-              const content = await this.git.showFile(currentGenSha, file);
-              return content === null;
-            }));
+            const isUserOwned = await Promise.all(
+              patch.files.map(async (file) => {
+                if (file === ".fernignore") {
+                  return true;
+                }
+                if (fernignorePatterns.some((p) => file === p || minimatch(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, {
@@ -20670,23 +20945,18 @@ var init_ReplayService = __esm({
        */
       async trimAbsorbedFiles(result, currentGenSha) {
         const cleanFiles = result.fileResults.filter((f) => f.status === "merged").map((f) => f.file);
-        if (cleanFiles.length === 0)
-          return;
+        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 || minimatch(file, p)))
-            continue;
+          if (file === ".fernignore") continue;
+          if (fernignorePatterns.some((p) => file === p || minimatch(file, p))) continue;
           const content = await this.git.showFile(currentGenSha, file);
-          if (content === null)
-            continue;
+          if (content === null) continue;
           generatorCleanFiles.push(file);
         }
-        if (generatorCleanFiles.length === 0)
-          return;
+        if (generatorCleanFiles.length === 0) return;
         const absorbedFiles = /* @__PURE__ */ new Set();
         for (const file of generatorCleanFiles) {
           try {
@@ -20697,11 +20967,9 @@ var init_ReplayService = __esm({
           } catch {
           }
         }
-        if (absorbedFiles.size === 0)
-          return;
+        if (absorbedFiles.size === 0) return;
         const remainingFiles = patch.files.filter((f) => !absorbedFiles.has(f));
-        if (remainingFiles.length === patch.files.length)
-          return;
+        if (remainingFiles.length === patch.files.length) return;
         try {
           this.lockManager.updatePatch(patch.id, { files: remainingFiles });
         } catch {
@@ -20726,8 +20994,7 @@ var init_ReplayService = __esm({
           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 === null) continue;
               if (!diff.trim()) {
                 this.lockManager.removePatch(patch.id);
                 contentRefreshed++;
@@ -20754,11 +21021,9 @@ var init_ReplayService = __esm({
           }
           try {
             const markerFiles = await this.git.exec(["grep", "-l", "<<<<<<<", "HEAD", "--", ...patch.files]).catch(() => "");
-            if (markerFiles.trim())
-              continue;
+            if (markerFiles.trim()) continue;
             const diff = await this.git.exec(["diff", currentGen, "HEAD", "--", ...patch.files]).catch(() => null);
-            if (diff === null)
-              continue;
+            if (diff === null) continue;
             if (!diff.trim()) {
               this.lockManager.removePatch(patch.id);
               conflictAbsorbed++;
@@ -20777,10 +21042,9 @@ var init_ReplayService = __esm({
         return { conflictResolved, conflictAbsorbed, contentRefreshed };
       }
       readFernignorePatterns() {
-        const fernignorePath = (0, import_node_path4.join)(this.outputDir, ".fernignore");
-        if (!(0, import_node_fs2.existsSync)(fernignorePath))
-          return [];
-        return (0, import_node_fs2.readFileSync)(fernignorePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+        const fernignorePath = (0, import_path10.join)(this.outputDir, ".fernignore");
+        if (!(0, import_fs7.existsSync)(fernignorePath)) return [];
+        return (0, import_fs7.readFileSync)(fernignorePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
       }
       buildReport(flow, patches, results, options, warnings, rebaseCounts, preRebaseCounts) {
         const conflictResults = results.filter((r) => r.status === "conflict");
@@ -20816,20 +21080,6 @@ var init_ReplayService = __esm({
         };
       }
     };
-  }
-});
-
-// ../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/FernignoreMigrator.js
-var import_node_crypto2, import_node_fs3, import_node_path5, import_yaml2, FernignoreMigrator;
-var init_FernignoreMigrator = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/FernignoreMigrator.js"() {
-    "use strict";
-    import_node_crypto2 = require("crypto");
-    import_node_fs3 = require("fs");
-    import_node_path5 = require("path");
-    init_esm3();
-    import_yaml2 = __toESM(require_dist3(), 1);
-    init_ReplayDetector();
     FernignoreMigrator = class {
       git;
       lockManager;
@@ -20840,14 +21090,14 @@ var init_FernignoreMigrator = __esm({
         this.outputDir = outputDir;
       }
       fernignoreExists() {
-        return (0, import_node_fs3.existsSync)((0, import_node_path5.join)(this.outputDir, ".fernignore"));
+        return (0, import_fs8.existsSync)((0, import_path11.join)(this.outputDir, ".fernignore"));
       }
       readFernignorePatterns() {
-        const fernignorePath = (0, import_node_path5.join)(this.outputDir, ".fernignore");
-        if (!(0, import_node_fs3.existsSync)(fernignorePath)) {
+        const fernignorePath = (0, import_path11.join)(this.outputDir, ".fernignore");
+        if (!(0, import_fs8.existsSync)(fernignorePath)) {
           return [];
         }
-        const content = (0, import_node_fs3.readFileSync)(fernignorePath, "utf-8");
+        const content = (0, import_fs8.readFileSync)(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. */
@@ -20894,9 +21144,9 @@ var init_FernignoreMigrator = __esm({
             }
             if (patchFiles.length > 0) {
               const patchContent = diffParts.join("\n");
-              const contentHash = `sha256:${(0, import_node_crypto2.createHash)("sha256").update(patchContent).digest("hex")}`;
+              const contentHash = `sha256:${(0, import_crypto2.createHash)("sha256").update(patchContent).digest("hex")}`;
               syntheticPatches.push({
-                id: `patch-fernignore-${(0, import_node_crypto2.createHash)("sha256").update(pattern).digest("hex").slice(0, 8)}`,
+                id: `patch-fernignore-${(0, import_crypto2.createHash)("sha256").update(pattern).digest("hex").slice(0, 8)}`,
                 content_hash: contentHash,
                 original_commit: currentGen.commit_sha,
                 original_message: `[fernignore-migration] Customizations for ${pattern}`,
@@ -20928,22 +21178,24 @@ var init_FernignoreMigrator = __esm({
         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) => minimatch(f, pattern) || f === pattern || f.startsWith(pattern + "/"));
+          const matching = allFiles.filter(
+            (f) => minimatch(f, pattern) || f === pattern || f.startsWith(pattern + "/")
+          );
           results.push({ pattern, files: matching.length > 0 ? matching : [pattern] });
         }
         return results;
       }
       readFileContent(filePath) {
-        const fullPath = (0, import_node_path5.join)(this.outputDir, filePath);
-        if (!(0, import_node_fs3.existsSync)(fullPath)) {
+        const fullPath = (0, import_path11.join)(this.outputDir, filePath);
+        if (!(0, import_fs8.existsSync)(fullPath)) {
           return null;
         }
         try {
-          const stat = (0, import_node_fs3.statSync)(fullPath);
+          const stat = (0, import_fs8.statSync)(fullPath);
           if (stat.isDirectory()) {
             return null;
           }
-          return (0, import_node_fs3.readFileSync)(fullPath, "utf-8");
+          return (0, import_fs8.readFileSync)(fullPath, "utf-8");
         } catch {
           return null;
         }
@@ -20981,421 +21233,43 @@ var init_FernignoreMigrator = __esm({
         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 = (0, import_node_path5.join)(this.outputDir, ".fern", "replay.yml");
-        let config = {};
-        if ((0, import_node_fs3.existsSync)(replayYmlPath)) {
-          const content = (0, import_node_fs3.readFileSync)(replayYmlPath, "utf-8");
-          config = (0, import_yaml2.parse)(content) ?? {};
-        }
-        const existing = config.exclude ?? [];
-        const merged = [.../* @__PURE__ */ new Set([...existing, ...patterns])];
-        config.exclude = merged;
-        const dir = (0, import_node_path5.dirname)(replayYmlPath);
-        if (!(0, import_node_fs3.existsSync)(dir)) {
-          (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
-        }
-        (0, import_node_fs3.writeFileSync)(replayYmlPath, (0, import_yaml2.stringify)(config, { lineWidth: 0 }), "utf-8");
-      }
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/commands/bootstrap.js
-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);
+          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 = (0, import_path11.join)(this.outputDir, ".fern", "replay.yml");
+        let config = {};
+        if ((0, import_fs8.existsSync)(replayYmlPath)) {
+          const content = (0, import_fs8.readFileSync)(replayYmlPath, "utf-8");
+          config = (0, import_yaml2.parse)(content) ?? {};
+        }
+        const existing = config.exclude ?? [];
+        const merged = [.../* @__PURE__ */ new Set([...existing, ...patterns])];
+        config.exclude = merged;
+        const dir = (0, import_path11.dirname)(replayYmlPath);
+        if (!(0, import_fs8.existsSync)(dir)) {
+          (0, import_fs8.mkdirSync)(dir, { recursive: true });
+        }
+        (0, import_fs8.writeFileSync)(replayYmlPath, (0, import_yaml2.stringify)(config, { lineWidth: 0 }), "utf-8");
       }
-    }
-  }
-  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 };
-  });
-}
-function ensureFernignoreEntries(outputDir) {
-  const fernignorePath = (0, import_node_path6.join)(outputDir, ".fernignore");
-  let content = "";
-  if ((0, import_node_fs4.existsSync)(fernignorePath)) {
-    content = (0, import_node_fs4.readFileSync)(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";
-  (0, import_node_fs4.writeFileSync)(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:${(0, import_node_crypto3.createHash)("sha256").update(normalized).digest("hex")}`;
-}
-var import_node_crypto3, import_node_fs4, import_node_path6, REPLAY_FERNIGNORE_ENTRIES;
-var init_bootstrap = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/commands/bootstrap.js"() {
-    "use strict";
-    import_node_crypto3 = require("crypto");
-    import_node_fs4 = require("fs");
-    import_node_path6 = require("path");
-    init_FernignoreMigrator();
-    init_CommitDetection();
-    init_GitClient();
-    init_LockfileManager();
-    REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml"];
-  }
-});
-
-// ../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/commands/forget.js
-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 || minimatch(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 };
-}
-var init_forget = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/commands/forget.js"() {
-    "use strict";
-    init_esm3();
-    init_LockfileManager();
-  }
-});
-
-// ../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/commands/reset.js
-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) {
-    (0, import_node_fs5.unlinkSync)(lockManager.lockfilePath);
-  }
-  return {
-    success: true,
-    patchesRemoved: patchCount,
-    lockfileDeleted: true,
-    nothingToReset: false
-  };
-}
-var import_node_fs5;
-var init_reset2 = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/commands/reset.js"() {
-    "use strict";
-    import_node_fs5 = require("fs");
-    init_LockfileManager();
-  }
-});
-
-// ../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/commands/resolve.js
-async function resolve7(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 };
-}
-var init_resolve = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/commands/resolve.js"() {
-    "use strict";
     init_GitClient();
-    init_LockfileManager();
-    init_ReplayCommitter();
-  }
-});
-
-// ../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/commands/status.js
-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 };
-}
-var init_status2 = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/commands/status.js"() {
-    "use strict";
-    init_LockfileManager();
-  }
-});
-
-// ../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/commands/index.js
-var init_commands = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/commands/index.js"() {
-    "use strict";
-    init_bootstrap();
-    init_forget();
-    init_reset2();
-    init_resolve();
-    init_status2();
-  }
-});
-
-// ../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/index.js
-var dist_exports = {};
-__export(dist_exports, {
-  FERN_BOT_EMAIL: () => FERN_BOT_EMAIL2,
-  FERN_BOT_LOGIN: () => FERN_BOT_LOGIN2,
-  FERN_BOT_NAME: () => FERN_BOT_NAME2,
-  FernignoreMigrator: () => FernignoreMigrator,
-  GitClient: () => GitClient,
-  LockfileManager: () => LockfileManager,
-  ReplayApplicator: () => ReplayApplicator,
-  ReplayCommitter: () => ReplayCommitter,
-  ReplayDetector: () => ReplayDetector,
-  ReplayService: () => ReplayService,
-  bootstrap: () => bootstrap,
-  forget: () => forget,
-  isGenerationCommit: () => isGenerationCommit,
-  isReplayCommit: () => isReplayCommit,
-  reset: () => reset,
-  resolve: () => resolve7,
-  status: () => status,
-  threeWayMerge: () => threeWayMerge
-});
-var init_dist = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.6.0/node_modules/@fern-api/replay/dist/index.js"() {
-    "use strict";
+    REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml"];
     init_GitClient();
-    init_CommitDetection();
-    init_LockfileManager();
-    init_ReplayDetector();
-    init_ThreeWayMerge();
-    init_ReplayApplicator();
-    init_ReplayCommitter();
-    init_ReplayService();
-    init_FernignoreMigrator();
-    init_commands();
   }
 });
 
@@ -21433,9 +21307,9 @@ function resolve(...paths) {
 }
 
 // src/cli.ts
-var import_fs9 = __toESM(require("fs"));
+var import_fs14 = __toESM(require("fs"));
 var import_promises9 = require("fs/promises");
-var import_path11 = __toESM(require("path"));
+var import_path16 = __toESM(require("path"));
 
 // ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/yerror.js
 var YError = class _YError extends Error {
@@ -31705,16 +31579,16 @@ function sleep(ms) {
 // src/replay/replay-run.ts
 init_dist();
 var import_child_process3 = require("child_process");
-var import_fs7 = require("fs");
-var import_path9 = require("path");
+var import_fs12 = require("fs");
+var import_path14 = require("path");
 
 // src/replay/fernignore.ts
-var import_fs6 = require("fs");
+var import_fs11 = require("fs");
 var import_promises5 = require("fs/promises");
-var import_path8 = require("path");
+var import_path13 = require("path");
 var REPLAY_FERNIGNORE_ENTRIES2 = [".fern/replay.lock", ".fern/replay.yml"];
 async function ensureReplayFernignoreEntries(outputDir) {
-  const fernignorePath = (0, import_path8.join)(outputDir, ".fernignore");
+  const fernignorePath = (0, import_path13.join)(outputDir, ".fernignore");
   let content = "";
   try {
     content = await (0, import_promises5.readFile)(fernignorePath, "utf-8");
@@ -31730,16 +31604,16 @@ async function ensureReplayFernignoreEntries(outputDir) {
   return false;
 }
 function ensureReplayFernignoreEntriesSync(outputDir) {
-  const fernignorePath = (0, import_path8.join)(outputDir, ".fernignore");
+  const fernignorePath = (0, import_path13.join)(outputDir, ".fernignore");
   let content = "";
-  if ((0, import_fs6.existsSync)(fernignorePath)) {
-    content = (0, import_fs6.readFileSync)(fernignorePath, "utf-8");
+  if ((0, import_fs11.existsSync)(fernignorePath)) {
+    content = (0, import_fs11.readFileSync)(fernignorePath, "utf-8");
   }
   const lines = content.split("\n");
   const toAdd = REPLAY_FERNIGNORE_ENTRIES2.filter((entry) => !lines.some((line) => line.trim() === entry));
   if (toAdd.length > 0) {
     const suffix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
-    (0, import_fs6.writeFileSync)(fernignorePath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
+    (0, import_fs11.writeFileSync)(fernignorePath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
   }
 }
 
@@ -31754,8 +31628,8 @@ async function replayRun(params) {
     skipApplication,
     logger
   } = params;
-  const lockfilePath = (0, import_path9.join)(outputDir, ".fern", "replay.lock");
-  if (!(0, import_fs7.existsSync)(lockfilePath)) {
+  const lockfilePath = (0, import_path14.join)(outputDir, ".fern", "replay.lock");
+  if (!(0, import_fs12.existsSync)(lockfilePath)) {
     return {
       report: null,
       fernignoreUpdated: false,
@@ -32017,8 +31891,8 @@ var PostGenerationPipeline = class {
 
 // src/replay/replay-init.ts
 init_dist();
-var import_fs8 = require("fs");
-var import_path10 = require("path");
+var import_fs13 = require("fs");
+var import_path15 = require("path");
 var import_tmp_promise2 = __toESM(require_tmp_promise());
 async function replayInit(params) {
   const { githubRepo, token, dryRun } = params;
@@ -32049,7 +31923,7 @@ async function replayInit(params) {
 Tracked ${bootstrapResult.patchesCreated} customization patch(es).
 Base generation: ${bootstrapResult.generationCommit.sha.slice(0, 7)}`;
   const filesToAdd = [".fern/replay.lock", ".fern/replay.yml", ".fernignore"].filter(
-    (f) => (0, import_fs8.existsSync)((0, import_path10.join)(repoPath, f))
+    (f) => (0, import_fs13.existsSync)((0, import_path15.join)(repoPath, f))
   );
   const branchName = `fern-replay/init-${Date.now()}`;
   await repository.checkoutOrCreateLocal(branchName);
@@ -32385,8 +32259,8 @@ void yargs_default(hideBin(process.argv)).scriptName(process.env.CLI_NAME ?? "ge
         const result = await pipeline.run();
         if (argv["result-file"] != null) {
           const resultPath = resolve(wd, argv["result-file"]);
-          await (0, import_promises9.mkdir)(import_path11.default.dirname(resultPath), { recursive: true });
-          await import_fs9.default.promises.writeFile(resultPath, JSON.stringify(result, null, 2));
+          await (0, import_promises9.mkdir)(import_path16.default.dirname(resultPath), { recursive: true });
+          await import_fs14.default.promises.writeFile(resultPath, JSON.stringify(result, null, 2));
         }
         process.stderr.write(`Pipeline ${result.success ? "succeeded" : "failed"}
 `);
@@ -32592,9 +32466,9 @@ async function createWriteStream(outputPath) {
 }
 async function createWriteStreamFromFile(filepath) {
   if (!await doesPathExist(filepath)) {
-    await (0, import_promises9.mkdir)(import_path11.default.dirname(filepath), { recursive: true });
+    await (0, import_promises9.mkdir)(import_path16.default.dirname(filepath), { recursive: true });
   }
-  return import_fs9.default.createWriteStream(filepath);
+  return import_fs14.default.createWriteStream(filepath);
 }
 /*! Bundled license information: