@fern-api/generator-cli 0.9.10 → 0.9.13

package/dist/api.js

@@ -793,12 +793,12 @@ var require_src2 = __commonJS({
     function check(path3, isFile, isDirectory) {
       log(`checking %s`, path3);
       try {
-        const stat = fs_1.statSync(path3);
-        if (stat.isFile() && isFile) {
+        const stat2 = fs_1.statSync(path3);
+        if (stat2.isFile() && isFile) {
           log(`[OK] path represents a file`);
           return true;
         }
-        if (stat.isDirectory() && isDirectory) {
+        if (stat2.isDirectory() && isDirectory) {
           log(`[OK] path represents a directory`);
           return true;
         }
@@ -881,6 +881,7 @@ var require_dist2 = __commonJS({
 var api_exports2 = {};
 __export(api_exports2, {
   PostGenerationPipeline: () => PostGenerationPipeline,
+  ReplaySubmitError: () => ReplaySubmitError,
   consolePipelineLogger: () => consolePipelineLogger,
   formatBootstrapSummary: () => formatBootstrapSummary,
   formatReplayPrBody: () => formatReplayPrBody,
@@ -892,11 +893,13 @@ __export(api_exports2, {
   githubPush: () => githubPush,
   githubRelease: () => githubRelease,
   logReplaySummary: () => logReplaySummary,
+  parseOwnerRepo: () => parseOwnerRepo,
   replayForget: () => replayForget,
   replayInit: () => replayInit,
   replayResolve: () => replayResolve,
   replayRun: () => replayRun,
-  replayStatus: () => replayStatus
+  replayStatus: () => replayStatus,
+  submitReplayInit: () => submitReplayInit
 });
 module.exports = __toCommonJS(api_exports2);
 
@@ -6017,6 +6020,46 @@ var ClonedRepository = class _ClonedRepository {
     const result = await this.git.raw(["rev-parse", "HEAD^{tree}"]);
     return result.trim();
   }
+  async getHeadCommitMessage() {
+    await this.git.cwd(this.clonePath);
+    const result = await this.git.raw(["log", "-1", "--format=%B", "HEAD"]);
+    return result.replace(/\n$/, "");
+  }
+  async getHeadParents() {
+    await this.git.cwd(this.clonePath);
+    const result = await this.git.raw(["rev-list", "--parents", "-n", "1", "HEAD"]);
+    const parts = result.trim().split(/\s+/);
+    return parts.slice(1);
+  }
+  /**
+   * Pushes a specific object (commit SHA) to a remote ref.
+   * Used to upload tree and blob objects to the remote without moving a branch.
+   *
+   * Pass `force: true` when overwriting a ref that may already point to an
+   * unrelated commit (e.g. retrying a temp ref after a local rebase rewrites
+   * history so the new SHA is not a descendant of the previous one).
+   */
+  async pushObjectToRef(localSha, remoteRef, { force = false } = {}) {
+    await this.git.cwd(this.clonePath);
+    const spec = force ? `+${localSha}:${remoteRef}` : `${localSha}:${remoteRef}`;
+    await this.git.raw(["push", "origin", spec]);
+  }
+  /**
+   * Resets the current branch HEAD to the given SHA. After fetching a newly-created remote
+   * signed commit, use this to align the local branch so subsequent operations (tag push,
+   * getHeadSha(), etc.) see the signed SHA.
+   */
+  async resetHardToSha(sha) {
+    await this.git.cwd(this.clonePath);
+    await this.git.raw(["reset", "--hard", sha]);
+  }
+  /**
+   * Rebases the current branch onto the given remote branch (`git pull --rebase origin <branch>`).
+   */
+  async pullWithRebase(branch) {
+    await this.git.cwd(this.clonePath);
+    await this.git.raw(["pull", "origin", branch, "--rebase"]);
+  }
   async getCommitTreeHash(commitSha) {
     await this.git.cwd(this.clonePath);
     const result = await this.git.raw(["rev-parse", `${commitSha}^{tree}`]);
@@ -10017,177 +10060,1944 @@ var consolePipelineLogger = {
 };
 
 // src/pipeline/PostGenerationPipeline.ts
-var import_child_process4 = require("child_process");
+var import_child_process5 = require("child_process");
 
 // src/pipeline/github/constants.ts
 var FERN_BOT_NAME = "fern-api";
 var FERN_BOT_EMAIL = "115122769+fern-api[bot]@users.noreply.github.com";
 var FERN_BOT_LOGIN = "fern-api[bot]";
 
-// src/pipeline/steps/GithubStep.ts
-var import_rest2 = require("@octokit/rest");
+// src/pipeline/steps/AutoVersionStep.ts
+var import_child_process3 = require("child_process");
+var import_fs3 = require("fs");
+var import_promises3 = require("fs/promises");
+var import_path4 = require("path");
+
+// src/autoversion/AutoVersioningService.ts
+var import_logging_execa = require("@fern-api/logging-execa");
+var import_fs2 = require("fs");
 var import_promises2 = require("fs/promises");
 var import_path3 = require("path");
-
-// src/pipeline/github/createReplayBranch.ts
-async function createReplayBranch(repository, branchName, commitMessage, replayConflictInfo, logger) {
-  if (replayConflictInfo == null) {
-    await repository.createBranchFromHead(branchName);
-    return void 0;
+var import_semver = __toESM(require("semver"));
+var AutoVersioningException = class extends Error {
+  /**
+   * True when the magic version was not found at all in the diff,
+   * indicating a generator that doesn't embed versions in source files
+   * (e.g., Swift uses git tags via SPM). Only this case should fall back
+   * to reading git tags.
+   */
+  magicVersionAbsent;
+  constructor(message, options) {
+    super(message);
+    this.name = "AutoVersioningException";
+    this.magicVersionAbsent = options?.magicVersionAbsent ?? false;
+    if (options?.cause) {
+      this.cause = options.cause;
+    }
   }
-  const parentSha = replayConflictInfo.previousGenerationSha;
-  await repository.createBranchFromHead(branchName);
-  const genTreeHash = await repository.getCommitTreeHash(replayConflictInfo.currentGenerationSha);
-  const tagCommitSha = await repository.commitTree(
-    genTreeHash,
-    parentSha,
-    `[fern-generated] ${commitMessage ?? "Update SDK"}`
-  );
-  return tagCommitSha;
-}
-
-// src/pipeline/github/findExistingUpdatablePR.ts
-async function findExistingUpdatablePR(octokit, owner, repo, baseBranch, logger) {
-  try {
-    const { data: pulls } = await octokit.pulls.list({
-      owner,
-      repo,
-      state: "open",
-      base: baseBranch,
-      sort: "updated",
-      direction: "desc",
-      per_page: 20
-    });
-    for (const pr of pulls) {
-      const prAuthor = pr.user?.login;
-      if (prAuthor !== FERN_BOT_LOGIN) {
-        logger.debug(`PR #${pr.number}: author ${prAuthor} is not ${FERN_BOT_LOGIN}, checking commits anyway`);
+};
+function countFilesInDiff(diffContent) {
+  const marker = "diff --git ";
+  let count = 0;
+  let pos = 0;
+  while (true) {
+    const idx = diffContent.indexOf(marker, pos);
+    if (idx === -1) {
+      break;
+    }
+    if (idx === 0 || diffContent[idx - 1] === "\n") {
+      count++;
+    }
+    pos = idx + marker.length;
+  }
+  return count;
+}
+function formatSizeKB(charLength) {
+  return (charLength / 1024).toFixed(1);
+}
+var EXCLUDED_FILE_PATTERNS = [
+  // Documentation / generated reference
+  /(?:^|\/)reference\.md$/i,
+  /(?:^|\/)changelog(?:\.[^/]*)?$/i,
+  /(?:^|\/)readme(?:\.[^/]*)?$/i,
+  /(?:^|\/)license(?:\.[^/]*)?$/i,
+  // Lock files (dependency resolution, zero semantic value)
+  /(?:^|\/)pnpm-lock\.yaml$/i,
+  /(?:^|\/)yarn\.lock$/i,
+  /(?:^|\/)package-lock\.json$/i,
+  /(?:^|\/)poetry\.lock$/i,
+  /(?:^|\/)gemfile\.lock$/i,
+  /(?:^|\/)go\.sum$/i,
+  /(?:^|\/)cargo\.lock$/i,
+  /(?:^|\/)composer\.lock$/i,
+  /\.lock$/i,
+  // catch-all for any other lockfiles
+  // Test files (by naming convention only — directory patterns like tests/ and
+  // test/ are intentionally omitted because a customer's API domain could use
+  // those names, e.g. a QA platform SDK with a "tests" resource)
+  /\.test\.ts$/i,
+  /\.test\.js$/i,
+  /\.test\.py$/i,
+  /\.spec\.ts$/i,
+  /\.spec\.js$/i,
+  /_test\.go$/i,
+  /_test\.py$/i,
+  /Test\.java$/,
+  /(?:^|\/)__tests__\//i,
+  // __tests__/ is unambiguously a test directory
+  /(?:^|\/)wiremock\//i,
+  // Fern-generated WireMock test fixtures
+  // Snapshot files
+  /(?:^|\/)__snapshots__\//i,
+  /\.snap$/i,
+  // CI / editor config (no API surface relevance)
+  /(?:^|\/)\.github\//i,
+  /(?:^|\/)\.circleci\//i,
+  /(?:^|\/)\.editorconfig$/i,
+  /(?:^|\/)\.prettierrc/i,
+  /(?:^|\/)biome\.json$/i,
+  // Linting / static analysis config
+  /(?:^|\/)\.eslintrc/i,
+  /(?:^|\/)eslint\.config\./i,
+  /(?:^|\/)\.rubocop/i,
+  // Ruby linter
+  /(?:^|\/)phpstan\.neon$/i,
+  // PHP static analysis
+  /(?:^|\/)phpunit\.xml$/i,
+  // PHP test runner config
+  /(?:^|\/)\.pylintrc$/i,
+  // Python linter
+  /(?:^|\/)pylintrc$/i,
+  /(?:^|\/)\.flake8$/i,
+  // Python linter
+  /(?:^|\/)\.mypy\.ini$/i,
+  // Python type checker
+  /(?:^|\/)mypy\.ini$/i,
+  /(?:^|\/)\.swiftlint\.yml$/i,
+  // Swift linter
+  /(?:^|\/)\.scalafmt\.conf$/i,
+  // Scala formatter
+  /(?:^|\/)rustfmt\.toml$/i,
+  // Rust formatter
+  /(?:^|\/)\.stylelintrc/i,
+  // CSS linter
+  // Build / devtool config (no API surface)
+  /(?:^|\/)tsconfig[^/]*\.json$/i,
+  // TypeScript compiler config
+  /(?:^|\/)vitest\.config\./i,
+  // Test runner config
+  /(?:^|\/)jest\.config\./i,
+  // Test runner config
+  /(?:^|\/)pnpm-workspace\.yaml$/i,
+  // Workspace config
+  /(?:^|\/)\.npmrc$/i,
+  // npm config
+  /(?:^|\/)\.yarnrc/i,
+  // Yarn config
+  /(?:^|\/)tox\.ini$/i,
+  // Python test runner
+  /(?:^|\/)Makefile$/i,
+  // Build automation
+  /(?:^|\/)Rakefile$/i,
+  // Ruby build tasks
+  /(?:^|\/)contributing(?:\.[^/]*)?$/i,
+  // Contributor docs
+  /(?:^|\/)snippet\.json$/i,
+  // Fern-generated snippet metadata
+  /(?:^|\/)\.gitignore$/i,
+  /(?:^|\/)\.gitattributes$/i,
+  /\.slnx$/i
+  // .NET solution files
+];
+var AutoVersioningService = class _AutoVersioningService {
+  logger;
+  constructor({ logger }) {
+    this.logger = logger;
+  }
+  /**
+   * Extracts the previous version from a git diff by finding lines with the magic version.
+   * The diff should contain lines like: -version = '1.2.3'  +version = '0.0.0-fern-placeholder'
+   *
+   * @param diffContent The git diff content
+   * @param mappedMagicVersion The magic version after language transformations (e.g., "v0.0.0-fern-placeholder" for Go)
+   * @return The previous version if found, or undefined if all magic version occurrences are in new files
+   * @throws AutoVersioningException if the magic version is not found at all in the diff
+   */
+  extractPreviousVersion(diffContent, mappedMagicVersion) {
+    const lines = diffContent.split("\n");
+    let currentFile = "unknown";
+    let magicVersionOccurrences = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line) {
+        continue;
       }
-      if (!pr.head.ref.startsWith("fern-bot/")) {
-        logger.debug(`PR #${pr.number} skipped: branch ${pr.head.ref} does not start with fern-bot/`);
+      if (line.startsWith("+++ b/")) {
+        currentFile = line.substring(6);
+      }
+      if (line.startsWith("+") && !line.startsWith("+++") && line.includes(mappedMagicVersion)) {
+        magicVersionOccurrences++;
+        const sanitizedPlusLine = line.replace(mappedMagicVersion, "<MAGIC>");
+        this.logger.debug(
+          `Found placeholder version in added line (file: ${currentFile}): ${sanitizedPlusLine}`
+        );
+        const matchingMinusLine = this.findMatchingMinusLine(lines, i, mappedMagicVersion);
+        if (matchingMinusLine == void 0) {
+          this.logger.debug(
+            `No matching minus line in hunk; continuing search. file=${currentFile}, plusLine=${sanitizedPlusLine}`
+          );
+          continue;
+        }
+        const extracted = this.extractPreviousVersionFromDiffLine(matchingMinusLine);
+        if (extracted != void 0) {
+          this.logger.debug(`Extracted previous version from diff (file: ${currentFile}): ${extracted}`);
+          return extracted;
+        }
+        this.logger.debug(
+          `Could not parse version from matching minus line (file: ${currentFile}); continuing search.`
+        );
         continue;
       }
-      const hasOnlyGenerationCommits = await checkPRHasOnlyGenerationCommits(
-        octokit,
-        owner,
-        repo,
-        pr.number,
-        logger
+    }
+    if (magicVersionOccurrences > 0) {
+      this.logger.info(
+        `Found placeholder version in the diff but no matching previous version lines were found in any hunk. This indicates a new SDK repository with no previous version. occurrences=${magicVersionOccurrences}`
       );
-      if (hasOnlyGenerationCommits) {
-        logger.debug(`Found existing updatable PR #${pr.number} with branch ${pr.head.ref}`);
-        return {
-          number: pr.number,
-          headBranch: pr.head.ref,
-          htmlUrl: pr.html_url,
-          isDraft: pr.draft ?? false,
-          nodeId: pr.node_id
-        };
-      } else {
-        logger.debug(`PR #${pr.number} skipped: contains non-generation commits`);
+      return void 0;
+    }
+    throw new AutoVersioningException(
+      "Failed to extract version from diff. This may indicate the version file format is not supported for auto-versioning, or the placeholder version was not found in any added lines.",
+      { magicVersionAbsent: true }
+    );
+  }
+  /**
+   * Scans backwards from the given index to find a '-' line that forms a version-change pair
+   * with the '+' line at the given index. Stops at hunk boundaries.
+   *
+   * @param lines All diff lines
+   * @param plusLineIndex Index of the '+' line containing the magic version
+   * @param mappedMagicVersion The magic version to match
+   * @return The matching '-' line, or null if not found
+   */
+  findMatchingMinusLine(lines, plusLineIndex, mappedMagicVersion) {
+    const plusLine = lines[plusLineIndex];
+    if (!plusLine) {
+      return void 0;
+    }
+    let linesScanned = 0;
+    for (let i = plusLineIndex - 1; i >= 0; i--) {
+      const line = lines[i];
+      if (!line) {
+        continue;
+      }
+      linesScanned++;
+      if (this.shouldStopSearching(line)) {
+        this.logger.debug(`Stopped backward scan at hunk boundary after ${linesScanned} lines`);
+        break;
+      }
+      if (this.isDeletionLine(line)) {
+        if (this.isVersionChangePair(line, plusLine, mappedMagicVersion)) {
+          this.logger.debug(`Found matching minus line after scanning ${linesScanned} lines backwards`);
+          return line;
+        }
       }
     }
-    return void 0;
-  } catch (error) {
-    logger.debug(`Error finding existing PRs: ${extractErrorMessage(error)}`);
+    this.logger.warn(`No matching minus line found after scanning ${linesScanned} lines backwards`);
     return void 0;
   }
-}
-async function checkPRHasOnlyGenerationCommits(octokit, owner, repo, pullNumber, logger) {
-  try {
-    const { data: commits } = await octokit.pulls.listCommits({
-      owner,
-      repo,
-      pull_number: pullNumber,
-      per_page: 100
-    });
-    for (const commit of commits) {
-      const authorLogin = commit.author?.login;
-      const authorEmail = commit.commit.author?.email;
-      const commitMessage = commit.commit.message ?? "";
-      const isFernAuthor = authorLogin === FERN_BOT_LOGIN || authorEmail === "115122769+fern-api[bot]@users.noreply.github.com" || commit.commit.author?.name === "fern-api";
-      const isFernCommitMessage = commitMessage.startsWith("[fern-generated]") || commitMessage.startsWith("[fern-replay]");
-      if (!isFernAuthor && !isFernCommitMessage) {
-        logger.debug(
-          `Commit ${commit.sha.substring(0, 7)} is not a generation commit: author=${authorLogin}, email=${authorEmail}, message="${commitMessage.slice(0, 40)}"`
-        );
-        return false;
+  /**
+   * Cleans the git diff by removing version-related changes.
+   * This prevents the AI from seeing our placeholder version and the version changes themselves.
+   *
+   * Algorithm:
+   * 1. Parse diff into file sections (each starting with "diff --git")
+   * 2. For each file section, identify and remove paired - and + lines where the only difference is the magic version
+   * 3. Remove entire file sections that have no remaining content changes (no + or - lines)
+   *
+   * @param diffContent The git diff content
+   * @param mappedMagicVersion The magic version after language transformations (e.g., "v0.0.0-fern-placeholder" for Go)
+   * @return Cleaned diff content
+   */
+  cleanDiffForAI(diffContent, mappedMagicVersion) {
+    const lines = diffContent.split("\n");
+    const fileSections = this.parseFileSections(lines);
+    const cleanedSections = [];
+    for (const section of fileSections) {
+      const filePath = this.extractFilePathFromSection(section);
+      if (filePath != null && this.shouldExcludeFile(filePath)) {
+        this.logger.debug(`Excluding file from diff analysis: ${filePath}`);
+        continue;
+      }
+      const cleaned = this.cleanFileSection(section, mappedMagicVersion);
+      if (cleaned != void 0) {
+        cleanedSections.push(cleaned);
       }
     }
-    return true;
-  } catch (error) {
-    logger.debug(`Error checking PR commits: ${extractErrorMessage(error)}`);
-    return false;
+    const result = [];
+    for (const section of cleanedSections) {
+      for (const line of section.lines) {
+        result.push(line);
+      }
+    }
+    this.logger.debug(
+      `Cleaned diff: removed ${diffContent.length - result.join("\n").length} chars containing version changes`
+    );
+    return result.join("\n");
   }
-}
-
-// src/pipeline/github/parseCommitMessage.ts
-function parseCommitMessageForPR(commitMessage, changelogEntry, prDescription, versionBumpReason, previousVersion, newVersion, versionBump, changelogUrl) {
-  const lines = commitMessage.split("\n");
-  const prTitle = lines[0]?.trim() || "SDK Generation";
-  const bodyFromCommit = lines.slice(1).join("\n").trim() || "Automated SDK generation by Fern";
-  let prBody = prDescription?.trim() || changelogEntry?.trim() || bodyFromCommit;
-  const isBreaking = versionBump === "MAJOR";
-  if (previousVersion?.trim() && newVersion?.trim()) {
-    const emoji = isBreaking ? "\u26A0\uFE0F " : "";
-    const header = `## ${emoji}${previousVersion.trim()} \u2192 ${newVersion.trim()}`;
-    if (isBreaking && versionBumpReason?.trim()) {
-      prBody = `${header}
-
-**Breaking:** ${versionBumpReason.trim()}
-
-${prBody}`;
-    } else {
-      prBody = `${header}
-
-${prBody}`;
+  /**
+   * Known patterns for API-surface signatures (function/method/class declarations).
+   * Used by truncateDiff to prioritise sections with signature-like changes.
+   *
+   * Covers all languages Fern generates SDKs for:
+   * - TypeScript/JavaScript: export function, export class, export interface, export type
+   * - Java/C#: public class, public interface, public void, protected, internal
+   * - Python: def method_name, class ClassName
+   * - Go: func ExportedName (uppercase = exported)
+   * - Ruby: def method_name, class ClassName, module ModuleName
+   * - Swift: public func, public class, open class
+   * - Rust: pub fn, pub struct, pub enum, pub trait
+   * - PHP: public function, class ClassName
+   */
+  static SIGNATURE_PATTERNS = [
+    // TypeScript / JavaScript
+    /^[+-]\s*export\s+/,
+    // Java / C# / Swift / PHP — access modifiers
+    /^[+-]\s*public\s+/,
+    /^[+-]\s*protected\s+/,
+    /^[+-]\s*internal\s+/,
+    /^[+-]\s*open\s+(class|func)\s+/,
+    // Python / Ruby
+    /^[+-]\s*def\s+/,
+    /^[+-]\s*class\s+[A-Z]/,
+    /^[+-]\s*module\s+[A-Z]/,
+    // Go — exported identifiers start with uppercase
+    /^[+-]\s*func\s+[A-Z]/,
+    /^[+-]\s*func\s+\([^)]+\)\s+[A-Z]/,
+    /^[+-]\s*type\s+[A-Z]/,
+    // Rust
+    /^[+-]\s*pub\s+(fn|struct|enum|trait|type|mod)\s+/,
+    // PHP
+    /^[+-]\s*function\s+/
+  ];
+  /**
+   * Splits a cleaned diff into chunks that each fit within a byte budget.
+   * File sections are ranked by semantic priority (same 5-tier system as
+   * classifySection) so the first chunk always contains the highest-signal
+   * sections. Each chunk contains only complete file sections — no partial
+   * files.
+   *
+   * If a single file section exceeds `maxBytesPerChunk`, it is placed alone
+   * in its own chunk so no information is lost.
+   *
+   * @param diff The cleaned diff string (output of cleanDiffForAI)
+   * @param maxBytesPerChunk Maximum byte size for each chunk
+   * @return Array of diff chunk strings (at least one element for non-empty diffs)
+   */
+  chunkDiff(diff, maxBytesPerChunk) {
+    const lines = diff.split("\n");
+    const fileSections = this.parseFileSections(lines);
+    if (fileSections.length === 0) {
+      return [diff];
+    }
+    const ranked = fileSections.map((section) => ({
+      text: section.lines.join("\n"),
+      priority: this.classifySection(section)
+    })).sort((a, b2) => a.priority - b2.priority);
+    const chunks = [];
+    let currentChunkTexts = [];
+    let currentChunkBytes = 0;
+    for (const entry of ranked) {
+      const sectionBytes = Buffer.byteLength(entry.text, "utf-8");
+      const newlineBytes = currentChunkTexts.length > 0 ? 1 : 0;
+      if (sectionBytes > maxBytesPerChunk) {
+        if (currentChunkTexts.length > 0) {
+          chunks.push(currentChunkTexts.join("\n"));
+          currentChunkTexts = [];
+        }
+        currentChunkBytes = 0;
+        chunks.push(entry.text);
+        continue;
+      }
+      if (currentChunkBytes + sectionBytes + newlineBytes > maxBytesPerChunk && currentChunkTexts.length > 0) {
+        chunks.push(currentChunkTexts.join("\n"));
+        currentChunkTexts = [];
+        currentChunkBytes = 0;
+      }
+      currentChunkTexts.push(entry.text);
+      currentChunkBytes += sectionBytes + (currentChunkTexts.length > 1 ? 1 : 0);
     }
-  } else if (isBreaking && versionBumpReason?.trim()) {
-    prBody = `\u26A0\uFE0F **Breaking:** ${versionBumpReason.trim()}
-
-${prBody}`;
+    if (currentChunkTexts.length > 0) {
+      chunks.push(currentChunkTexts.join("\n"));
+    }
+    return chunks;
   }
-  if (changelogUrl?.trim()) {
-    prBody += `
-
----
-
-[See full changelog](${changelogUrl.trim()})`;
+  /**
+   * Classifies a file section into a priority bucket for truncation ranking.
+   * Lower number = higher priority (included first).
+   *
+   * 1 = deletion-only, 2 = mixed with signatures, 3 = mixed,
+   * 4 = addition-only, 5 = context-only
+   */
+  static isDiffHeader(line) {
+    return line.startsWith("--- a/") || line.startsWith("--- /dev/null") || line.startsWith("+++ b/") || line.startsWith("+++ /dev/null");
+  }
+  classifySection(section) {
+    let hasAdditions = false;
+    let hasDeletions = false;
+    let hasSignature = false;
+    for (const line of section.lines) {
+      const isAddition = line.startsWith("+") && !_AutoVersioningService.isDiffHeader(line);
+      const isDeletion = line.startsWith("-") && !_AutoVersioningService.isDiffHeader(line);
+      if (isAddition) {
+        hasAdditions = true;
+      }
+      if (isDeletion) {
+        hasDeletions = true;
+      }
+      if (isAddition || isDeletion) {
+        for (const pattern of _AutoVersioningService.SIGNATURE_PATTERNS) {
+          if (pattern.test(line)) {
+            hasSignature = true;
+            break;
+          }
+        }
+      }
+      if (hasAdditions && hasDeletions && hasSignature) {
+        break;
+      }
+    }
+    if (hasDeletions && !hasAdditions) {
+      return 1;
+    }
+    if (hasDeletions && hasAdditions && hasSignature) {
+      return 2;
+    }
+    if (hasDeletions && hasAdditions) {
+      return 3;
+    }
+    if (hasAdditions) {
+      return 4;
+    }
+    return 5;
   }
-  return { prTitle, prBody };
-}
-
-// src/pipeline/replay-summary.ts
-function plural(n, word) {
-  return `${n} ${word}${n === 1 ? "" : "s"}`;
-}
-function formatConflictReason(reason) {
-  switch (reason) {
-    case "same-line-edit":
-      return "The new generation changed the same lines you edited";
-    case "new-file-both":
-      return "Both the generator and your customization created this file";
-    case "base-generation-mismatch":
-      return "This customization was from a previous generation";
-    case "patch-apply-failed":
-      return "The customization could not be applied to the new code";
-    default:
-      return "Your edit overlaps with changes in the new generation";
+  /**
+   * Parses a diff into file sections, where each section starts with "diff --git".
+   */
+  parseFileSections(lines) {
+    const sections = [];
+    let currentSection = void 0;
+    for (const line of lines) {
+      if (line.startsWith("diff --git")) {
+        if (currentSection != void 0) {
+          sections.push(currentSection);
+        }
+        currentSection = { lines: [line] };
+      } else if (currentSection != void 0) {
+        currentSection.lines.push(line);
+      }
+    }
+    if (currentSection != void 0) {
+      sections.push(currentSection);
+    }
+    return sections;
   }
-}
-function patchDescription(detail) {
-  if (detail.patchMessage && detail.patchMessage !== "update") {
-    return detail.patchMessage;
+  /**
+   * Cleans a single file section by removing version-related changes.
+   * Returns null if the file section should be completely removed.
+   */
+  cleanFileSection(section, mappedMagicVersion) {
+    const headerLines = [];
+    const contentLines = [];
+    let inContent = false;
+    for (const line of section.lines) {
+      if (line.startsWith("@@")) {
+        inContent = true;
+        headerLines.push(line);
+      } else if (!inContent) {
+        headerLines.push(line);
+      } else {
+        contentLines.push(line);
+      }
+    }
+    let processedContent = this.removeVersionChangePairs(contentLines, mappedMagicVersion);
+    processedContent = this.removeRemainingMagicVersionLines(processedContent, mappedMagicVersion);
+    let hasChanges = false;
+    for (const line of processedContent) {
+      const isAddition = line.startsWith("+") && !_AutoVersioningService.isDiffHeader(line);
+      const isDeletion = line.startsWith("-") && !_AutoVersioningService.isDiffHeader(line);
+      if (isAddition || isDeletion) {
+        hasChanges = true;
+        break;
+      }
+    }
+    if (!hasChanges) {
+      return void 0;
+    }
+    const cleaned = { lines: [] };
+    cleaned.lines.push(...headerLines);
+    cleaned.lines.push(...processedContent);
+    return cleaned;
   }
-  const firstFile = detail.files[0];
-  return firstFile != null ? `changes in ${firstFile}` : "customization";
-}
-function logReplaySummary(result, logger) {
-  if (!result.executed) {
-    return;
+  /**
+   * Removes any remaining lines (additions, deletions, or context) that contain the magic version.
+   * This is a secondary pass to catch any lines that the pairing logic missed.
+   */
+  removeRemainingMagicVersionLines(lines, mappedMagicVersion) {
+    const result = [];
+    for (const line of lines) {
+      if (line.includes(mappedMagicVersion)) {
+        continue;
+      }
+      result.push(line);
+    }
+    return result;
   }
-  const applied = result.patchesApplied ?? 0;
-  const absorbed = result.patchesAbsorbed ?? 0;
+  /**
+   * Removes paired - and + lines where the only difference is the magic version.
+   */
+  removeVersionChangePairs(lines, mappedMagicVersion) {
+    const result = [];
+    let lineIndex = 0;
+    while (lineIndex < lines.length) {
+      const currentLine = lines[lineIndex];
+      if (!currentLine) {
+        lineIndex++;
+        continue;
+      }
+      if (this.isDeletionLine(currentLine)) {
+        const pairIndex = this.findMatchingAdditionLine(lines, lineIndex, mappedMagicVersion);
+        if (pairIndex !== -1) {
+          result.push(...lines.slice(lineIndex + 1, pairIndex));
+          lineIndex = pairIndex + 1;
+        } else {
+          result.push(currentLine);
+          lineIndex++;
+        }
+      } else {
+        result.push(currentLine);
+        lineIndex++;
+      }
+    }
+    return result;
+  }
+  isDeletionLine(line) {
+    return line.startsWith("-") && !_AutoVersioningService.isDiffHeader(line);
+  }
+  findMatchingAdditionLine(lines, startIndex, mappedMagicVersion) {
+    const startLine = lines[startIndex];
+    if (!startLine) {
+      return -1;
+    }
+    for (let nextIndex = startIndex + 1; nextIndex < lines.length; nextIndex++) {
+      const nextLine = lines[nextIndex];
+      if (!nextLine) {
+        continue;
+      }
+      if (this.shouldStopSearching(nextLine)) {
+        break;
+      }
+      if (this.isAdditionLine(nextLine)) {
+        if (this.isVersionChangePair(startLine, nextLine, mappedMagicVersion)) {
+          return nextIndex;
+        }
+      }
+    }
+    return -1;
+  }
+  isAdditionLine(line) {
+    return line.startsWith("+") && !_AutoVersioningService.isDiffHeader(line);
+  }
+  shouldStopSearching(line) {
+    return line.startsWith("@@") || line.startsWith("diff --git") || line.startsWith("index ") || _AutoVersioningService.isDiffHeader(line);
+  }
+  /**
+   * Checks if two lines form a version change pair where the only difference is the magic version,
+   * or where the only difference is a Go module path /vN suffix.
+   */
+  isVersionChangePair(minusLine, plusLine, mappedMagicVersion) {
+    if (this.isGoModulePathSuffixChange(minusLine, plusLine)) {
+      return true;
+    }
+    if (!plusLine.includes(mappedMagicVersion)) {
+      return false;
+    }
+    const minusContent = minusLine.substring(1);
+    const plusContent = plusLine.substring(1);
+    const magicIndex = plusContent.indexOf(mappedMagicVersion);
+    if (magicIndex === -1) {
+      return false;
+    }
+    const plusPrefix = plusContent.substring(0, magicIndex);
+    const plusSuffix = plusContent.substring(magicIndex + mappedMagicVersion.length);
+    if (!minusContent.startsWith(plusPrefix)) {
+      return false;
+    }
+    const versionStart = plusPrefix.length;
+    const versionEnd = minusContent.length - plusSuffix.length;
+    if (versionEnd <= versionStart || versionEnd > minusContent.length) {
+      return false;
+    }
+    const minusVersion = minusContent.substring(versionStart, versionEnd);
+    const minusSuffix = minusContent.substring(versionEnd);
+    if (minusSuffix !== plusSuffix) {
+      return false;
+    }
+    return /.*\d+.*/.test(minusVersion);
+  }
+  /**
+   * Detects when two diff lines differ only by a Go module path /vN suffix.
+   * For example:
+   *   -  core "github.com/org/repo/core"
+   *   +  core "github.com/org/repo/v2/core"
+   * These are artifacts of the major version bump and should be filtered from AI analysis.
+   *
+   * Only matches lines that contain a quoted Go-style module path (e.g., "github.com/..."),
+   * so non-Go diffs like API URL version changes are not affected.
+   */
+  isGoModulePathSuffixChange(minusLine, plusLine) {
+    const minusContent = minusLine.substring(1);
+    const plusContent = plusLine.substring(1);
+    const goModulePathPattern = /"[^"]*(?:github\.com|golang\.org|google\.golang\.org|gopkg\.in)\/[^"]*"/;
+    const goModuleDirectivePattern = /^\s*module\s+(?:github\.com|golang\.org|google\.golang\.org|gopkg\.in)\/\S+/;
+    const hasGoModulePath = goModulePathPattern.test(minusContent) || goModulePathPattern.test(plusContent) || goModuleDirectivePattern.test(minusContent.trim()) || goModuleDirectivePattern.test(plusContent.trim());
+    if (!hasGoModulePath) {
+      return false;
+    }
+    const suffixPattern = /\/v\d+(?=\/|"\s*$|$)/g;
+    const minusWithoutSuffix = minusContent.replace(suffixPattern, "");
+    const plusWithoutSuffix = plusContent.replace(suffixPattern, "");
+    if (minusWithoutSuffix !== plusWithoutSuffix) {
+      return false;
+    }
+    return /\/v\d+(?=\/|"\s*$|$)/.test(minusContent) || /\/v\d+(?=\/|"\s*$|$)/.test(plusContent);
+  }
+  /**
+   * Gets the latest semantic version from git tags in the given repository.
+   * Used as a fallback when the magic version is not embedded in any generated file
+   * (e.g., Swift SDKs which use git tags for versioning via SPM, not a version file).
+   *
+   * @param workingDirectory The git repository directory
+   * @return The latest semver version from git tags, or undefined if no valid tags found
+   */
+  async getLatestVersionFromGitTags(workingDirectory) {
+    try {
+      const result = await (0, import_logging_execa.loggingExeca)(this.logger, "git", ["ls-remote", "--tags", "origin"], {
+        cwd: workingDirectory,
+        doNotPipeOutput: true
+      });
+      const output = result.stdout;
+      if (!output || output.trim().length === 0) {
+        this.logger.info("No git tags found in repository");
+        return void 0;
+      }
+      const tags = [];
+      for (const line of output.split("\n")) {
+        const trimmed2 = line.trim();
+        if (trimmed2.length === 0 || trimmed2.includes("^{}")) {
+          continue;
+        }
+        const match = trimmed2.match(/refs\/tags\/(.+)$/);
+        if (match?.[1]) {
+          tags.push(match[1]);
+        }
+      }
+      const validTags = tags.filter((tag) => import_semver.default.valid(tag) != null).sort((a, b2) => import_semver.default.rcompare(a, b2));
+      if (validTags.length > 0) {
+        const latest = validTags[0];
+        this.logger.info(`Found latest version from git tags: ${latest}`);
+        return latest;
+      }
+      this.logger.info("No valid semver tags found in repository");
+      return void 0;
+    } catch (e) {
+      this.logger.warn(`Failed to read git tags: ${e}`);
+      return void 0;
+    }
+  }
+  /**
+   * Replaces all occurrences of the magic version with the final version in generated files.
+   *
+   * @param workingDirectory The directory containing generated files
+   * @param mappedMagicVersion The magic version after language transformations (e.g., "v0.0.0-fern-placeholder" for Go)
+   * @param finalVersion The final version to use
+   * @throws Error if file operations fail or find/sed command fails
+   */
+  async replaceMagicVersion(workingDirectory, mappedMagicVersion, finalVersion) {
+    this.logger.debug(`Replacing placeholder version ${mappedMagicVersion} with final version: ${finalVersion}`);
+    const sedCommand = `s/${this.escapeForSed(mappedMagicVersion)}/${this.escapeForSed(finalVersion)}/g`;
+    let isGNUSed = false;
+    try {
+      await (0, import_logging_execa.loggingExeca)(this.logger, "sed", ["--version"], {
+        doNotPipeOutput: true
+      });
+      isGNUSed = true;
+    } catch {
+      isGNUSed = false;
+    }
+    let command;
+    if (isGNUSed) {
+      command = `find "${workingDirectory}" -type f -not -path "*/.git/*" -exec sed -i '${sedCommand}' {} +`;
+    } else {
+      command = `find "${workingDirectory}" -type f -not -path "*/.git/*" -exec sed -i '' '${sedCommand}' {} +`;
+    }
+    await (0, import_logging_execa.loggingExeca)(this.logger, "bash", ["-c", command], {
+      cwd: workingDirectory,
+      doNotPipeOutput: true
+    });
+    this.logger.debug("Placeholder version replaced successfully");
+  }
+  /**
+   * Adds /vN suffix to Go module paths and import statements when the computed
+   * version is v2+. Go requires a /vN suffix on module paths for major versions >= 2.
+   *
+   * When using the safe magic version (major 0), the generated code has no /vN suffix.
+   * After auto-versioning determines the real version, this method adds the correct suffix.
+   *
+   * @param workingDirectory The directory containing generated Go files
+   * @param finalVersion The final computed version (e.g., "v2.0.0", "v3.1.0")
+   */
+  async addGoMajorVersionSuffix(workingDirectory, finalVersion) {
+    const major = this.extractMajorVersion(finalVersion);
+    if (major == null || major < 2) {
+      this.logger.debug(
+        `Version ${finalVersion} has major ${major ?? "unknown"}, no Go module path suffix needed`
+      );
+      return;
+    }
+    const goModPath = (0, import_path3.join)(workingDirectory, "go.mod");
+    if (!(0, import_fs2.existsSync)(goModPath)) {
+      this.logger.debug(`No go.mod found in ${workingDirectory}, skipping Go module path update`);
+      return;
+    }
+    const modulePath = await this.readGoModulePath(goModPath);
+    if (modulePath == null) {
+      this.logger.warn(`Could not read module path from go.mod in ${workingDirectory}`);
+      return;
+    }
+    const suffix = `/v${major}`;
+    if (/\/v\d+$/.test(modulePath)) {
+      this.logger.debug(`Module path ${modulePath} already has a version suffix, skipping`);
+      return;
+    }
+    await this.addSuffixToGoMod(goModPath, modulePath, suffix);
+    await this.addSuffixToGoFiles(workingDirectory, modulePath, suffix);
+    this.logger.info(`Added ${suffix} to Go module path ${modulePath} and all import paths`);
+  }
+  /**
+   * Extracts the major version number from a version string.
+   * Handles versions with or without 'v' prefix.
+   */
+  extractMajorVersion(version) {
+    const match = version.match(/^v?(\d+)\./);
+    if (match?.[1] != null) {
+      return parseInt(match[1], 10);
+    }
+    return void 0;
+  }
+  /**
+   * Reads the module path from a go.mod file.
+   */
+  async readGoModulePath(goModPath) {
+    const content = await (0, import_promises2.readFile)(goModPath, "utf-8");
+    for (const line of content.split("\n")) {
+      const trimmed2 = line.trim();
+      if (trimmed2.startsWith("module ")) {
+        return trimmed2.substring("module ".length).trim();
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Adds a version suffix to the module line in go.mod.
+   */
+  async addSuffixToGoMod(goModPath, modulePath, suffix) {
+    const content = await (0, import_promises2.readFile)(goModPath, "utf-8");
+    const lines = content.split("\n");
+    let changed = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line != null && line.trim().startsWith("module ") && line.includes(modulePath)) {
+        lines[i] = line.replace(modulePath, modulePath + suffix);
+        changed = true;
+        break;
+      }
+    }
+    if (changed) {
+      await (0, import_promises2.writeFile)(goModPath, lines.join("\n"), "utf-8");
+      this.logger.debug(`Updated go.mod: added ${suffix} to module path`);
+    }
+  }
+  /**
+   * Recursively walks a directory and returns all file paths matching a filter.
+   */
+  async walkDirectory(dir, filter) {
+    const results = [];
+    const entries2 = await (0, import_promises2.readdir)(dir);
+    for (const entry of entries2) {
+      const fullPath = (0, import_path3.join)(dir, entry);
+      const entryStat = await (0, import_promises2.stat)(fullPath);
+      if (entryStat.isDirectory()) {
+        if (entry === ".git" || entry === "vendor") {
+          continue;
+        }
+        const subResults = await this.walkDirectory(fullPath, filter);
+        results.push(...subResults);
+      } else if (filter(fullPath)) {
+        results.push(fullPath);
+      }
+    }
+    return results;
+  }
+  /**
+   * Adds a version suffix to import paths in all .go files in the repository.
+   */
+  async addSuffixToGoFiles(repoRoot, modulePath, suffix) {
+    const goFiles = await this.walkDirectory(repoRoot, (filePath) => (0, import_path3.extname)(filePath) === ".go");
+    for (const filePath of goFiles) {
+      await this.addSuffixToGoFile(filePath, modulePath, suffix);
+    }
+  }
+  /**
+   * Adds a version suffix to import paths in a single .go file.
+   * Replaces occurrences of the module path with modulePath + suffix in import statements.
+   */
+  async addSuffixToGoFile(filePath, modulePath, suffix) {
+    const content = await (0, import_promises2.readFile)(filePath, "utf-8");
+    const lines = content.split("\n");
+    let changed = false;
+    let inImportBlock = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line == null) {
+        continue;
+      }
+      const trimmed2 = line.trim();
+      if (trimmed2.startsWith("import (")) {
+        inImportBlock = true;
+      } else if (inImportBlock && trimmed2 === ")") {
+        inImportBlock = false;
+      }
+      const isImportLine = inImportBlock || trimmed2.startsWith('import "') || trimmed2.startsWith('import	"') || /^import\s+\w+\s+"/.test(trimmed2);
+      if (!isImportLine) {
+        continue;
+      }
+      if (!line.includes(modulePath)) {
+        continue;
+      }
+      const newLine = line.replace(`"${modulePath}/`, `"${modulePath}${suffix}/`).replace(`"${modulePath}"`, `"${modulePath}${suffix}"`);
+      if (newLine !== line) {
+        lines[i] = newLine;
+        changed = true;
+      }
+    }
+    if (changed) {
+      await (0, import_promises2.writeFile)(filePath, lines.join("\n"), "utf-8");
+      this.logger.debug(`Updated Go imports in ${filePath}`);
+    }
+  }
+  /**
+   * Escapes special characters for use in sed command.
+   */
+  escapeForSed(str) {
+    return str.replace(/[/&]/g, "\\$&");
+  }
+  /**
+   * Extracts the file path from a diff file section.
+   * Parses the "diff --git a/path b/path" header line.
+   */
+  extractFilePathFromSection(section) {
+    const firstLine = section.lines[0];
+    if (firstLine == null) {
+      return void 0;
+    }
+    const match = firstLine.match(/^diff --git "?a\/(.+?)"? "?b\/(.+?)"?$/);
+    if (match?.[2] != null) {
+      return match[2];
+    }
+    return void 0;
+  }
+  /**
+   * Checks whether a file path matches any of the exclusion patterns.
+   * Excluded files are noise for AI-based semantic version analysis.
+   */
+  shouldExcludeFile(filePath) {
+    return EXCLUDED_FILE_PATTERNS.some((pattern) => pattern.test(filePath));
+  }
+  /**
+   * Extracts the previous version from a line containing the magic version.
+   * Assumes the line format is like: "version = '0.0.0-fern-placeholder'" or "version: 0.0.0-fern-placeholder"
+   *
+   * @param lineWithMagicVersion A line from git diff containing the magic version
+   * @return The inferred previous version if found, or undefined if the version cannot be parsed
+   */
+  extractPreviousVersionFromDiffLine(lineWithMagicVersion) {
+    const prevVersionPattern = /[-].*?([v]?\d+\.\d+\.\d+(?:-[\w.-]+)?(?:\+[\w.-]+)?)/;
+    const matcher = lineWithMagicVersion.match(prevVersionPattern);
+    if (matcher && matcher[1]) {
+      const version = matcher[1];
+      this.logger.info(`Extracted previous version from diff: ${version}`);
+      return version;
+    }
+    this.logger.warn("Could not extract previous version from diff line: " + lineWithMagicVersion);
+    return void 0;
+  }
+};
+
+// src/autoversion/VersionUtils.ts
+var MAGIC_VERSION = "0.0.0-fern-placeholder";
+var MAGIC_VERSION_PYTHON = "0.0.0.dev0";
+function mapMagicVersionForLanguage(magicVersion, language) {
+  if (magicVersion !== MAGIC_VERSION) {
+    return magicVersion;
+  }
+  if (language === "go") {
+    return `v${magicVersion}`;
+  }
+  if (language === "python") {
+    return MAGIC_VERSION_PYTHON;
+  }
+  return magicVersion;
+}
+var MAX_AI_DIFF_BYTES = 4e4;
+var MAX_CHUNKS = 40;
+var MAX_RAW_DIFF_BYTES = 1e7;
+var VERSION_BUMP_RANK = {
+  ["MAJOR" /* MAJOR */]: 3,
+  ["MINOR" /* MINOR */]: 2,
+  ["PATCH" /* PATCH */]: 1,
+  ["NO_CHANGE" /* NO_CHANGE */]: 0
+};
+function maxVersionBump(a, b2) {
+  return (VERSION_BUMP_RANK[a] ?? 0) >= (VERSION_BUMP_RANK[b2] ?? 0) ? a : b2;
+}
+var SEMVER_PATTERN = /^(v)?(\d+)\.(\d+)\.(\d+)(?:-([\w.-]+))?(?:\+([\w.-]+))?$/;
+function isValidSemver(version) {
+  return SEMVER_PATTERN.test(version);
+}
+function incrementVersion(currentVersion, versionBump) {
+  const matcher = currentVersion.match(SEMVER_PATTERN);
+  if (!matcher) {
+    throw new AutoVersioningException("Invalid semantic version format: " + currentVersion);
+  }
+  const prefix = matcher[1] || "";
+  let major = parseInt(matcher[2] ?? "0", 10);
+  let minor = parseInt(matcher[3] ?? "0", 10);
+  let patch = parseInt(matcher[4] ?? "0", 10);
+  const preRelease = matcher[5];
+  const buildMetadata = matcher[6];
+  let preserveMetadata = false;
+  if (versionBump === "MAJOR" /* MAJOR */) {
+    major++;
+    minor = 0;
+    patch = 0;
+  } else if (versionBump === "MINOR" /* MINOR */) {
+    minor++;
+    patch = 0;
+  } else if (versionBump === "PATCH" /* PATCH */) {
+    patch++;
+  } else if (versionBump === "NO_CHANGE" /* NO_CHANGE */) {
+    preserveMetadata = true;
+  } else {
+    throw new AutoVersioningException("Unknown version bump type: " + versionBump);
+  }
+  let newVersion = `${prefix}${major}.${minor}.${patch}`;
+  if (preserveMetadata) {
+    if (preRelease) {
+      newVersion += `-${preRelease}`;
+    }
+    if (buildMetadata) {
+      newVersion += `+${buildMetadata}`;
+    }
+  }
+  return newVersion;
+}
+
+// src/pipeline/steps/BaseStep.ts
+var BaseStep = class {
+  constructor(outputDir, logger) {
+    this.outputDir = outputDir;
+    this.logger = logger;
+  }
+  outputDir;
+  logger;
+};
+
+// src/pipeline/steps/AutoVersionStep.ts
+var COMMIT_MARKER = "[fern-autoversion]";
+var FERN_TRAILER = "\n\n\u{1F33F} Generated with Fern";
+var AutoVersionStep = class extends BaseStep {
+  constructor(outputDir, logger, config) {
+    super(outputDir, logger);
+    this.config = config;
+  }
+  config;
+  name = "autoVersion";
+  async execute(context) {
+    const prepared = context.previousStepResults.generationCommit?.preparedReplay;
+    if (!prepared) {
+      this.logger.info(
+        "AutoVersionStep: no replay preparation available (replay uninitialized or prepare failed); skipping."
+      );
+      return { executed: true, success: true };
+    }
+    if (prepared.flow === "skip-application") {
+      this.logger.info("AutoVersionStep: replay flow is skip-application; skipping autoversion.");
+      return { executed: true, success: true };
+    }
+    const language = this.config.language;
+    const mappedMagicVersion = mapMagicVersionForLanguage(MAGIC_VERSION, language);
+    const service = new AutoVersioningService({ logger: this.toTaskLogger() });
+    if (prepared.previousGenerationSha == null) {
+      return await this.handleFirstGeneration({ service, language, mappedMagicVersion });
+    }
+    return await this.handleNormalFlow({
+      prepared,
+      service,
+      language,
+      mappedMagicVersion,
+      previousGenerationSha: prepared.previousGenerationSha
+    });
+  }
+  async handleFirstGeneration(params) {
+    const { service, language, mappedMagicVersion } = params;
+    const initialVersion = this.config.baseVersion ?? (mappedMagicVersion.startsWith("v") ? "v0.0.1" : "0.0.1");
+    if (!isValidSemver(initialVersion)) {
+      const errorMessage = `AutoVersionStep: baseVersion ${JSON.stringify(initialVersion)} is not a valid semver string (expected e.g. "1.2.3" or "v1.2.3"). Refusing to run to avoid shell injection into the placeholder-rewrite step.`;
+      this.logger.error(errorMessage);
+      return {
+        executed: true,
+        success: false,
+        errorMessage
+      };
+    }
+    this.logger.info(`AutoVersionStep: first generation \u2014 using initial version ${initialVersion}`);
+    await service.replaceMagicVersion(this.outputDir, mappedMagicVersion, initialVersion);
+    if (language === "go") {
+      await service.addGoMajorVersionSuffix(this.outputDir, initialVersion);
+    }
+    const commitMessage = this.brandMessage("Initial SDK generation");
+    const commitSha = this.commitAutoversion(commitMessage);
+    return {
+      executed: true,
+      success: true,
+      version: initialVersion,
+      commitMessage,
+      commitSha
+    };
+  }
+  async handleNormalFlow(params) {
+    const { prepared, service, language, mappedMagicVersion, previousGenerationSha } = params;
+    const rawDiff = this.gitDiff(previousGenerationSha, prepared.currentGenerationSha);
+    if (rawDiff.trim().length === 0) {
+      this.logger.info("AutoVersionStep: empty diff between generations; skipping autoversion.");
+      return { executed: true, success: true };
+    }
+    const previousVersion = await this.resolvePreviousVersion({ service, rawDiff, mappedMagicVersion });
+    if (previousVersion == null) {
+      return await this.handleFirstGeneration({ service, language, mappedMagicVersion });
+    }
+    const cleanedDiff = service.cleanDiffForAI(rawDiff, mappedMagicVersion);
+    const rawBytes = Buffer.byteLength(rawDiff, "utf-8");
+    const cleanedBytes = Buffer.byteLength(cleanedDiff, "utf-8");
+    this.logger.debug(
+      `AutoVersionStep: raw=${formatSizeKB(rawBytes)}KB (${countFilesInDiff(rawDiff)} files), cleaned=${formatSizeKB(cleanedBytes)}KB (${countFilesInDiff(cleanedDiff)} files)`
+    );
+    if (cleanedDiff.trim().length === 0) {
+      this.logger.info("AutoVersionStep: cleaned diff is empty; no semantic changes.");
+      return { executed: true, success: true };
+    }
+    if (cleanedBytes > MAX_RAW_DIFF_BYTES) {
+      this.logger.warn(
+        `AutoVersionStep: diff too large for FAI (${formatSizeKB(cleanedBytes)}KB, limit ${formatSizeKB(MAX_RAW_DIFF_BYTES)}KB). Falling back to PATCH.`
+      );
+      return await this.finalizeWithBump({
+        service,
+        language,
+        mappedMagicVersion,
+        previousVersion,
+        analysis: { versionBump: "PATCH", message: this.brandMessage("SDK regeneration") }
+      });
+    }
+    const chunks = service.chunkDiff(cleanedDiff, MAX_AI_DIFF_BYTES);
+    const cappedChunks = chunks.slice(0, MAX_CHUNKS);
+    const skippedChunks = chunks.length - cappedChunks.length;
+    if (chunks.length > 1) {
+      this.logger.info(
+        `AutoVersionStep: split diff into ${chunks.length} chunks` + (skippedChunks > 0 ? ` (capped at ${MAX_CHUNKS}, skipping ${skippedChunks})` : "")
+      );
+    }
+    let analysis;
+    try {
+      analysis = cappedChunks.length <= 1 ? await this.analyzeSingle(cleanedDiff, language, previousVersion) : await this.analyzeChunks(cappedChunks, language, previousVersion);
+    } catch (error) {
+      this.logger.warn(`AutoVersionStep: FAI analysis failed (${String(error)}); falling back to PATCH bump.`);
+      analysis = { versionBump: "PATCH", message: this.brandMessage("SDK regeneration") };
+    }
+    if (analysis == null) {
+      this.logger.info("AutoVersionStep: FAI returned NO_CHANGE; skipping autoversion commit.");
+      return {
+        executed: true,
+        success: true,
+        previousVersion,
+        versionBump: "NO_CHANGE"
+      };
+    }
+    return await this.finalizeWithBump({
+      service,
+      language,
+      mappedMagicVersion,
+      previousVersion,
+      analysis
+    });
+  }
+  async finalizeWithBump(params) {
+    const { service, language, mappedMagicVersion, previousVersion, analysis } = params;
+    const newVersion = incrementVersion(previousVersion, analysis.versionBump);
+    this.logger.info(`AutoVersionStep: ${analysis.versionBump} bump: ${previousVersion} \u2192 ${newVersion}`);
+    await service.replaceMagicVersion(this.outputDir, mappedMagicVersion, newVersion);
+    if (language === "go") {
+      await service.addGoMajorVersionSuffix(this.outputDir, newVersion);
+    }
+    if (analysis.changelogEntry && analysis.changelogEntry.trim().length > 0) {
+      await this.prependChangelogEntry({ version: newVersion, entry: analysis.changelogEntry });
+    }
+    const commitSha = this.commitAutoversion(analysis.message);
+    return {
+      executed: true,
+      success: true,
+      version: newVersion,
+      commitMessage: analysis.message,
+      changelogEntry: analysis.changelogEntry,
+      previousVersion,
+      versionBump: analysis.versionBump,
+      prDescription: analysis.prDescription,
+      versionBumpReason: analysis.versionBumpReason,
+      commitSha
+    };
+  }
+  async resolvePreviousVersion(params) {
+    const { service, rawDiff, mappedMagicVersion } = params;
+    try {
+      const extracted = service.extractPreviousVersion(rawDiff, mappedMagicVersion);
+      if (extracted != null) {
+        this.logger.debug(`AutoVersionStep: previous version from diff: ${extracted}`);
+        return extracted;
+      }
+    } catch (error) {
+      if (!(error instanceof AutoVersioningException) || !error.magicVersionAbsent) {
+        throw error;
+      }
+      this.logger.info("AutoVersionStep: magic version not found in diff; falling back to metadata + git tags.");
+    }
+    const metadataVersion = await this.readVersionFromMetadata();
+    if (metadataVersion != null) {
+      return this.normalizeVersionPrefix(metadataVersion, mappedMagicVersion);
+    }
+    try {
+      const tagVersion = await service.getLatestVersionFromGitTags(this.outputDir);
+      if (tagVersion != null) {
+        return this.normalizeVersionPrefix(tagVersion, mappedMagicVersion);
+      }
+    } catch (error) {
+      this.logger.debug(`AutoVersionStep: git-tags fallback failed (${String(error)}); ignoring.`);
+    }
+    return null;
+  }
+  async readVersionFromMetadata() {
+    try {
+      const output = (0, import_child_process3.execFileSync)("git", ["show", "HEAD~1:.fern/metadata.json"], {
+        cwd: this.outputDir,
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+      const parsed = JSON.parse(output);
+      return parsed.sdkVersion ?? void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  normalizeVersionPrefix(version, mappedMagicVersion) {
+    const stripped = version.startsWith("v") ? version.slice(1) : version;
+    return mappedMagicVersion.startsWith("v") ? `v${stripped}` : stripped;
+  }
+  gitDiff(from, to) {
+    return (0, import_child_process3.execFileSync)("git", ["diff", from, to, "--", ".", ":(exclude).fern/metadata.json"], {
+      cwd: this.outputDir,
+      encoding: "utf-8",
+      stdio: "pipe",
+      maxBuffer: 256 * 1024 * 1024
+    });
+  }
+  commitAutoversion(message) {
+    const subject = message.split("\n")[0] ?? message;
+    const body = message.slice(subject.length).trimStart();
+    const fullMessage = body.length > 0 ? `${COMMIT_MARKER} ${subject}
+
+${body}` : `${COMMIT_MARKER} ${subject}`;
+    (0, import_child_process3.execFileSync)("git", ["add", "-A"], { cwd: this.outputDir, stdio: "pipe" });
+    (0, import_child_process3.execFileSync)("git", ["commit", "--allow-empty", "-m", fullMessage], {
+      cwd: this.outputDir,
+      stdio: "pipe"
+    });
+    return (0, import_child_process3.execFileSync)("git", ["rev-parse", "HEAD"], {
+      cwd: this.outputDir,
+      encoding: "utf-8",
+      stdio: "pipe"
+    }).trim();
+  }
+  async prependChangelogEntry(params) {
+    const { version, entry } = params;
+    const changelogPath = (0, import_path4.join)(this.outputDir, "changelog.md");
+    const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const header = `## [${version}] - ${now}
+`;
+    const newBlock = `${header}${entry.trim()}
+
+`;
+    let existing = "";
+    if ((0, import_fs3.existsSync)(changelogPath)) {
+      existing = await (0, import_promises3.readFile)(changelogPath, "utf-8");
+    }
+    let output;
+    if (existing.trim().length === 0) {
+      output = `# Changelog
+
+${newBlock}`;
+    } else if (existing.startsWith("# Changelog")) {
+      const newlineIdx = existing.indexOf("\n");
+      const headerLine = newlineIdx >= 0 ? existing.slice(0, newlineIdx) : existing;
+      const remainder = (newlineIdx >= 0 ? existing.slice(newlineIdx + 1) : "").replace(/^\s*\n/, "");
+      output = `${headerLine}
+
+${newBlock}${remainder}`;
+    } else {
+      output = `${newBlock}${existing}`;
+    }
+    await (0, import_promises3.writeFile)(changelogPath, output, "utf-8");
+  }
+  brandMessage(message) {
+    if (this.config.isWhitelabel) {
+      return message;
+    }
+    if (message.includes("\u{1F33F} Generated with Fern")) {
+      return message;
+    }
+    return `${message.trimEnd()}${FERN_TRAILER}`;
+  }
+  async analyzeSingle(cleanedDiff, language, previousVersion) {
+    const { client, VersionBump: VersionBump2 } = await this.loadBaml();
+    const result = await client.AnalyzeSdkDiff(
+      cleanedDiff,
+      language,
+      previousVersion,
+      this.config.priorChangelog ?? "",
+      this.config.specCommitMessage ?? ""
+    );
+    if (result.version_bump === VersionBump2.NO_CHANGE) {
+      return null;
+    }
+    return {
+      versionBump: result.version_bump,
+      message: result.message,
+      changelogEntry: result.changelog_entry || void 0,
+      versionBumpReason: result.version_bump_reason || void 0
+    };
+  }
+  async analyzeChunks(chunks, language, previousVersion) {
+    const { client, VersionBump: VersionBump2 } = await this.loadBaml();
+    let bestBump = VersionBump2.NO_CHANGE;
+    let bestMessage = "";
+    let bestVersionBumpReason;
+    const changelogEntries = [];
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      if (!chunk) {
+        continue;
+      }
+      const analysis = await client.AnalyzeSdkDiff(
+        chunk,
+        language,
+        previousVersion,
+        this.config.priorChangelog ?? "",
+        this.config.specCommitMessage ?? ""
+      );
+      if (analysis.version_bump === VersionBump2.NO_CHANGE) {
+        continue;
+      }
+      const prev = bestBump;
+      bestBump = maxVersionBump(bestBump, analysis.version_bump);
+      if (bestBump !== prev) {
+        bestMessage = analysis.message;
+        bestVersionBumpReason = analysis.version_bump_reason;
+      }
+      const entry = analysis.changelog_entry?.trim();
+      if (entry) {
+        changelogEntries.push(entry);
+      }
+    }
+    if (bestBump === VersionBump2.NO_CHANGE) {
+      return null;
+    }
+    if (changelogEntries.length <= 1) {
+      return {
+        versionBump: bestBump,
+        message: bestMessage,
+        changelogEntry: changelogEntries[0],
+        versionBumpReason: bestVersionBumpReason
+      };
+    }
+    try {
+      const consolidated = await client.ConsolidateChangelog(
+        changelogEntries.join("\n\n"),
+        bestBump,
+        language,
+        previousVersion,
+        incrementVersion(previousVersion, bestBump)
+      );
+      return {
+        versionBump: bestBump,
+        message: bestMessage,
+        changelogEntry: consolidated.consolidated_changelog,
+        prDescription: consolidated.pr_description || void 0,
+        versionBumpReason: consolidated.version_bump_reason || bestVersionBumpReason
+      };
+    } catch (error) {
+      this.logger.warn(`AutoVersionStep: ConsolidateChangelog failed (${String(error)}); using joined entries.`);
+      return {
+        versionBump: bestBump,
+        message: bestMessage,
+        changelogEntry: changelogEntries.join("\n\n"),
+        versionBumpReason: bestVersionBumpReason
+      };
+    }
+  }
+  /**
+   * Dynamically imports @fern-api/cli-ai only when autoversion actually needs to
+   * call FAI. The package is ESM-only with extensionless internal imports, so
+   * unbundled CJS consumers (like generator-cli's `bin/cli` used by the README /
+   * reference commands) would fail at load time with a static import — but those
+   * commands never reach this method, so dynamic import keeps them unaffected.
+   */
+  async loadBaml() {
+    if (this.config.ai == null) {
+      throw new Error("AutoVersionStep: ai config is missing. Set autoVersion.ai to a BAML provider+model pair.");
+    }
+    const cliAi = await import("@fern-api/cli-ai");
+    const registry = cliAi.configureBamlClient(this.config.ai);
+    return {
+      client: cliAi.b.withOptions({ clientRegistry: registry }),
+      VersionBump: cliAi.VersionBump
+    };
+  }
+  /**
+   * AutoVersioningService was built against the CLI's TaskContext logger — a richer
+   * shape with `trace`, `log`, `enable`, `disable`. Our pipeline only has the four
+   * core levels; stub the rest as no-ops and adapt the method signatures. Cast to
+   * the service's expected Logger type because the surface is structurally wider
+   * than what PipelineLogger exposes.
+   */
+  toTaskLogger() {
+    const noop = () => void 0;
+    const adapter = {
+      debug: (msg) => this.logger.debug(msg),
+      info: (msg) => this.logger.info(msg),
+      warn: (msg) => this.logger.warn(msg),
+      error: (msg) => this.logger.error(msg),
+      trace: (msg) => this.logger.debug(msg),
+      log: (msg) => this.logger.info(msg),
+      enable: noop,
+      disable: noop
+    };
+    return adapter;
+  }
+};
+
+// src/replay/replay-run.ts
+var import_replay = require("@fern-api/replay");
+var import_child_process4 = require("child_process");
+var import_fs5 = require("fs");
+var import_path6 = require("path");
+
+// src/replay/fernignore.ts
+var import_fs4 = require("fs");
+var import_promises4 = require("fs/promises");
+var import_path5 = require("path");
+var REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml", ".gitattributes"];
+var GITATTRIBUTES_ENTRIES = [".fern/replay.lock linguist-generated=true"];
+async function ensureReplayFernignoreEntries(outputDir) {
+  const fernignorePath = (0, import_path5.join)(outputDir, ".fernignore");
+  let content = "";
+  try {
+    content = await (0, import_promises4.readFile)(fernignorePath, "utf-8");
+  } catch {
+  }
+  const lines = content.split("\n");
+  const toAdd = REPLAY_FERNIGNORE_ENTRIES.filter((entry) => !lines.some((line) => line.trim() === entry));
+  if (toAdd.length > 0) {
+    const suffix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
+    await (0, import_promises4.writeFile)(fernignorePath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
+    return true;
+  }
+  return false;
+}
+async function ensureGitattributesEntries(outputDir) {
+  const gitattributesPath = (0, import_path5.join)(outputDir, ".gitattributes");
+  let content = "";
+  try {
+    content = await (0, import_promises4.readFile)(gitattributesPath, "utf-8");
+  } catch {
+  }
+  const lines = content.split("\n");
+  const toAdd = GITATTRIBUTES_ENTRIES.filter((entry) => !lines.some((line) => line.trim() === entry));
+  if (toAdd.length > 0) {
+    const suffix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
+    await (0, import_promises4.writeFile)(gitattributesPath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
+  }
+}
+function ensureReplayFernignoreEntriesSync(outputDir) {
+  const fernignorePath = (0, import_path5.join)(outputDir, ".fernignore");
+  let content = "";
+  if ((0, import_fs4.existsSync)(fernignorePath)) {
+    content = (0, import_fs4.readFileSync)(fernignorePath, "utf-8");
+  }
+  const lines = content.split("\n");
+  const toAdd = REPLAY_FERNIGNORE_ENTRIES.filter((entry) => !lines.some((line) => line.trim() === entry));
+  if (toAdd.length > 0) {
+    const suffix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
+    (0, import_fs4.writeFileSync)(fernignorePath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
+  }
+}
+function ensureGitattributesEntriesSync(outputDir) {
+  const gitattributesPath = (0, import_path5.join)(outputDir, ".gitattributes");
+  let content = "";
+  if ((0, import_fs4.existsSync)(gitattributesPath)) {
+    content = (0, import_fs4.readFileSync)(gitattributesPath, "utf-8");
+  }
+  const lines = content.split("\n");
+  const toAdd = GITATTRIBUTES_ENTRIES.filter((entry) => !lines.some((line) => line.trim() === entry));
+  if (toAdd.length > 0) {
+    const suffix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
+    (0, import_fs4.writeFileSync)(gitattributesPath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
+  }
+}
+
+// src/replay/replay-run.ts
+async function replayPrepare(params) {
+  const {
+    outputDir,
+    cliVersion,
+    generatorVersions,
+    stageOnly = false,
+    generatorName,
+    skipApplication,
+    logger
+  } = params;
+  const lockfilePath = (0, import_path6.join)(outputDir, ".fern", "replay.lock");
+  if (!(0, import_fs5.existsSync)(lockfilePath)) {
+    return null;
+  }
+  const baseBranchHead = gitRevParse(outputDir, "HEAD");
+  let previousGenerationSha = null;
+  let prevBaseBranchHead = null;
+  try {
+    const lockManager = new import_replay.LockfileManager(outputDir);
+    if (lockManager.exists()) {
+      const lock = lockManager.read();
+      previousGenerationSha = lock.current_generation;
+      const latestGen = lock.generations.find((g2) => g2.commit_sha === lock.current_generation);
+      prevBaseBranchHead = latestGen?.base_branch_head ?? null;
+    }
+  } catch {
+  }
+  if (previousGenerationSha != null) {
+    const sanitizedName = generatorName?.replace(/\//g, "--");
+    const namespacedTag = sanitizedName != null ? `fern-generation-base--${sanitizedName}` : null;
+    const tagSha = (namespacedTag != null ? gitRevParse(outputDir, namespacedTag) : null) ?? gitRevParse(outputDir, "fern-generation-base");
+    let shouldSync = false;
+    if (tagSha != null) {
+      const tagParent = gitRevParse(outputDir, `${tagSha}^`);
+      if (tagParent === prevBaseBranchHead || tagParent === previousGenerationSha) {
+        const tagDistance = gitDiffNameOnly(outputDir, tagSha, "HEAD").length;
+        const lockDistance = gitDiffNameOnly(
+          outputDir,
+          prevBaseBranchHead ?? previousGenerationSha,
+          "HEAD"
+        ).length;
+        shouldSync = tagDistance < lockDistance;
+      }
+    }
+    if (shouldSync && tagSha != null) {
+      if (!isTagMergedIntoHead(outputDir, tagSha)) {
+        logger?.warn(
+          `fern-generation-base tag ${tagSha} is not reachable from HEAD \u2014 skipping divergent-merge sync. The tag likely points at an unmerged generation (PR closed without merge).`
+        );
+      } else {
+        const syncService = new import_replay.ReplayService(outputDir, { enabled: true });
+        await syncService.syncFromDivergentMerge(tagSha, {
+          cliVersion,
+          generatorVersions,
+          baseBranchHead: baseBranchHead ?? void 0
+        });
+        try {
+          const freshLockManager = new import_replay.LockfileManager(outputDir);
+          if (freshLockManager.exists()) {
+            previousGenerationSha = freshLockManager.read().current_generation;
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  const service = new import_replay.ReplayService(outputDir, { enabled: true });
+  let preparation;
+  try {
+    preparation = await service.prepareReplay({
+      cliVersion,
+      generatorVersions,
+      stageOnly,
+      skipApplication,
+      baseBranchHead: baseBranchHead ?? void 0
+    });
+  } catch (error) {
+    logger?.warn("Replay failed, continuing without replay: " + String(error));
+    return null;
+  }
+  return {
+    _service: service,
+    _preparation: preparation,
+    outputDir,
+    flow: preparation.flow,
+    previousGenerationSha,
+    currentGenerationSha: preparation.currentGenerationSha,
+    baseBranchHead
+  };
+}
+async function replayApply(prepared, params = {}) {
+  const { stageOnly = false, logger } = params;
+  let report;
+  try {
+    report = await prepared._service.applyPreparedReplay(prepared._preparation, { stageOnly });
+  } catch (error) {
+    logger?.warn("Replay failed, continuing without replay: " + String(error));
+    return {
+      report: null,
+      fernignoreUpdated: false,
+      previousGenerationSha: prepared.previousGenerationSha,
+      currentGenerationSha: prepared.currentGenerationSha,
+      baseBranchHead: prepared.baseBranchHead
+    };
+  }
+  let resolvedBaseBranchHead = prepared.baseBranchHead;
+  try {
+    const freshLockManager = new import_replay.LockfileManager(prepared.outputDir);
+    if (freshLockManager.exists()) {
+      const freshLock = freshLockManager.read();
+      const latestGen = freshLock.generations.find((g2) => g2.commit_sha === freshLock.current_generation);
+      if (latestGen?.base_branch_head) {
+        resolvedBaseBranchHead = latestGen.base_branch_head;
+      }
+    }
+  } catch {
+  }
+  const fernignoreUpdated = await ensureReplayFernignoreEntries(prepared.outputDir);
+  await ensureGitattributesEntries(prepared.outputDir);
+  return {
+    report,
+    fernignoreUpdated,
+    previousGenerationSha: prepared.previousGenerationSha,
+    currentGenerationSha: prepared.currentGenerationSha,
+    baseBranchHead: resolvedBaseBranchHead
+  };
+}
+async function replayRun(params) {
+  const prepared = await replayPrepare(params);
+  if (prepared == null) {
+    return {
+      report: null,
+      fernignoreUpdated: false,
+      previousGenerationSha: null,
+      currentGenerationSha: null,
+      baseBranchHead: null
+    };
+  }
+  return replayApply(prepared, { stageOnly: params.stageOnly, logger: params.logger });
+}
+function isTagMergedIntoHead(cwd2, tagSha) {
+  try {
+    (0, import_child_process4.execFileSync)("git", ["merge-base", "--is-ancestor", tagSha, "HEAD"], {
+      cwd: cwd2,
+      stdio: "pipe"
+    });
+    return true;
+  } catch {
+  }
+  const tagTree = gitRevParse(cwd2, `${tagSha}^{tree}`);
+  if (tagTree == null) {
+    return false;
+  }
+  try {
+    const trees = (0, import_child_process4.execFileSync)("git", ["log", "HEAD", "--format=%T", "--max-count=500"], {
+      cwd: cwd2,
+      encoding: "utf-8",
+      stdio: "pipe"
+    });
+    return trees.split("\n").some((t2) => t2.trim() === tagTree);
+  } catch {
+    return false;
+  }
+}
+function gitRevParse(cwd2, rev) {
+  try {
+    return (0, import_child_process4.execFileSync)("git", ["rev-parse", "--verify", rev], {
+      cwd: cwd2,
+      encoding: "utf-8",
+      stdio: "pipe"
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function gitDiffNameOnly(cwd2, from, to) {
+  try {
+    const output = (0, import_child_process4.execFileSync)("git", ["diff", "--name-only", from, to], {
+      cwd: cwd2,
+      encoding: "utf-8",
+      stdio: "pipe"
+    });
+    return output.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+// src/pipeline/steps/GenerationCommitStep.ts
+var GenerationCommitStep = class extends BaseStep {
+  constructor(outputDir, logger, config, cliVersion, generatorVersions, generatorName) {
+    super(outputDir, logger);
+    this.config = config;
+    this.cliVersion = cliVersion;
+    this.generatorVersions = generatorVersions;
+    this.generatorName = generatorName;
+  }
+  config;
+  cliVersion;
+  generatorVersions;
+  generatorName;
+  name = "generationCommit";
+  async execute(_context) {
+    const prepared = await replayPrepare({
+      outputDir: this.outputDir,
+      cliVersion: this.cliVersion,
+      generatorVersions: this.generatorVersions,
+      generatorName: this.generatorName,
+      skipApplication: this.config.skipApplication,
+      logger: this.logger
+    });
+    if (prepared == null) {
+      return {
+        executed: true,
+        success: true,
+        preparedReplay: null
+      };
+    }
+    return {
+      executed: true,
+      success: true,
+      preparedReplay: prepared,
+      previousGenerationSha: prepared.previousGenerationSha ?? void 0,
+      currentGenerationSha: prepared.currentGenerationSha,
+      baseBranchHead: prepared.baseBranchHead ?? void 0,
+      flow: prepared.flow
+    };
+  }
+};
+
+// src/pipeline/steps/GithubStep.ts
+var import_rest2 = require("@octokit/rest");
+var import_promises5 = require("fs/promises");
+var import_path7 = require("path");
+
+// src/pipeline/github/createReplayBranch.ts
+async function createReplayBranch(repository, branchName, commitMessage, replayConflictInfo, logger) {
+  if (replayConflictInfo == null) {
+    await repository.createBranchFromHead(branchName);
+    return void 0;
+  }
+  const parentSha = replayConflictInfo.previousGenerationSha;
+  await repository.createBranchFromHead(branchName);
+  const genTreeHash = await repository.getCommitTreeHash(replayConflictInfo.currentGenerationSha);
+  const tagCommitSha = await repository.commitTree(
+    genTreeHash,
+    parentSha,
+    `[fern-generated] ${commitMessage ?? "Update SDK"}`
+  );
+  return tagCommitSha;
+}
+
+// src/pipeline/github/findExistingUpdatablePR.ts
+async function findExistingUpdatablePR(octokit, owner, repo, baseBranch, logger) {
+  try {
+    const { data: pulls } = await octokit.pulls.list({
+      owner,
+      repo,
+      state: "open",
+      base: baseBranch,
+      sort: "updated",
+      direction: "desc",
+      per_page: 20
+    });
+    for (const pr of pulls) {
+      const prAuthor = pr.user?.login;
+      if (prAuthor !== FERN_BOT_LOGIN) {
+        logger.debug(`PR #${pr.number}: author ${prAuthor} is not ${FERN_BOT_LOGIN}, checking commits anyway`);
+      }
+      if (!pr.head.ref.startsWith("fern-bot/")) {
+        logger.debug(`PR #${pr.number} skipped: branch ${pr.head.ref} does not start with fern-bot/`);
+        continue;
+      }
+      const hasOnlyGenerationCommits = await checkPRHasOnlyGenerationCommits(
+        octokit,
+        owner,
+        repo,
+        pr.number,
+        logger
+      );
+      if (hasOnlyGenerationCommits) {
+        logger.debug(`Found existing updatable PR #${pr.number} with branch ${pr.head.ref}`);
+        return {
+          number: pr.number,
+          headBranch: pr.head.ref,
+          htmlUrl: pr.html_url,
+          isDraft: pr.draft ?? false,
+          nodeId: pr.node_id
+        };
+      } else {
+        logger.debug(`PR #${pr.number} skipped: contains non-generation commits`);
+      }
+    }
+    return void 0;
+  } catch (error) {
+    logger.debug(`Error finding existing PRs: ${extractErrorMessage(error)}`);
+    return void 0;
+  }
+}
+async function checkPRHasOnlyGenerationCommits(octokit, owner, repo, pullNumber, logger) {
+  try {
+    const { data: commits } = await octokit.pulls.listCommits({
+      owner,
+      repo,
+      pull_number: pullNumber,
+      per_page: 100
+    });
+    for (const commit of commits) {
+      const authorLogin = commit.author?.login;
+      const authorEmail = commit.commit.author?.email;
+      const commitMessage = commit.commit.message ?? "";
+      const isFernAuthor = authorLogin === FERN_BOT_LOGIN || authorEmail === "115122769+fern-api[bot]@users.noreply.github.com" || commit.commit.author?.name === "fern-api";
+      const isFernCommitMessage = commitMessage.startsWith("[fern-generated]") || commitMessage.startsWith("[fern-replay]");
+      if (!isFernAuthor && !isFernCommitMessage) {
+        logger.debug(
+          `Commit ${commit.sha.substring(0, 7)} is not a generation commit: author=${authorLogin}, email=${authorEmail}, message="${commitMessage.slice(0, 40)}"`
+        );
+        return false;
+      }
+    }
+    return true;
+  } catch (error) {
+    logger.debug(`Error checking PR commits: ${extractErrorMessage(error)}`);
+    return false;
+  }
+}
+
+// src/pipeline/github/parseCommitMessage.ts
+function parseCommitMessageForPR(commitMessage, changelogEntry, prDescription, versionBumpReason, previousVersion, newVersion, versionBump, changelogUrl) {
+  const lines = commitMessage.split("\n");
+  const prTitle = lines[0]?.trim() || "SDK Generation";
+  const bodyFromCommit = lines.slice(1).join("\n").trim() || "Automated SDK generation by Fern";
+  let prBody = prDescription?.trim() || changelogEntry?.trim() || bodyFromCommit;
+  const isBreaking = versionBump === "MAJOR";
+  if (previousVersion?.trim() && newVersion?.trim()) {
+    const emoji = isBreaking ? "\u26A0\uFE0F " : "";
+    const header = `## ${emoji}${previousVersion.trim()} \u2192 ${newVersion.trim()}`;
+    if (isBreaking && versionBumpReason?.trim()) {
+      prBody = `${header}
+
+**Breaking:** ${versionBumpReason.trim()}
+
+${prBody}`;
+    } else {
+      prBody = `${header}
+
+${prBody}`;
+    }
+  } else if (isBreaking && versionBumpReason?.trim()) {
+    prBody = `\u26A0\uFE0F **Breaking:** ${versionBumpReason.trim()}
+
+${prBody}`;
+  }
+  if (changelogUrl?.trim()) {
+    prBody += `
+
+---
+
+[See full changelog](${changelogUrl.trim()})`;
+  }
+  return { prTitle, prBody };
+}
+
+// src/pipeline/github/pushSignedCommit.ts
+var MAX_CONCURRENT_PUSH_RETRIES = 3;
+async function pushSignedCommit({
+  repository,
+  octokit,
+  owner,
+  repo,
+  branch,
+  force,
+  rebaseOnConflict = false,
+  logger
+}) {
+  const tempRef = `refs/temp/fern-${Date.now()}`;
+  let tempRefPushed = false;
+  try {
+    let [localHeadSha, treeSha, message, parents] = await Promise.all([
+      repository.getHeadSha(),
+      repository.getHeadTreeHash(),
+      repository.getHeadCommitMessage(),
+      repository.getHeadParents()
+    ]);
+    await repository.pushObjectToRef(localHeadSha, tempRef);
+    tempRefPushed = true;
+    for (let attempt = 0; attempt < MAX_CONCURRENT_PUSH_RETRIES; attempt++) {
+      const { data: signedCommit } = await octokit.git.createCommit({
+        owner,
+        repo,
+        message,
+        tree: treeSha,
+        parents
+      });
+      const signedSha = signedCommit.sha;
+      try {
+        await upsertBranchRef({ octokit, owner, repo, branch, sha: signedSha, force });
+        logger.debug(`Updated refs/heads/${branch} to signed commit ${signedSha}`);
+        await syncLocalToSignedCommit({ repository, branch, signedSha });
+        return signedSha;
+      } catch (err) {
+        if (!isNonFastForwardError(err) || force || attempt >= MAX_CONCURRENT_PUSH_RETRIES - 1) {
+          throw err;
+        }
+        if (rebaseOnConflict) {
+          logger.warn(
+            `Non-fast-forward on refs/heads/${branch} (attempt ${attempt + 1}/${MAX_CONCURRENT_PUSH_RETRIES}); rebasing locally and retrying.`
+          );
+          await repository.pullWithRebase(branch);
+          [localHeadSha, treeSha, message, parents] = await Promise.all([
+            repository.getHeadSha(),
+            repository.getHeadTreeHash(),
+            repository.getHeadCommitMessage(),
+            repository.getHeadParents()
+          ]);
+          await repository.pushObjectToRef(localHeadSha, tempRef, { force: true });
+        } else {
+          throw err;
+        }
+      }
+    }
+    throw new Error(
+      `Failed to push signed commit to refs/heads/${branch} after ${MAX_CONCURRENT_PUSH_RETRIES} attempts`
+    );
+  } finally {
+    if (tempRefPushed) {
+      try {
+        await octokit.git.deleteRef({ owner, repo, ref: tempRef.replace(/^refs\//, "") });
+      } catch (err) {
+        logger.debug(`Failed to delete temp ref ${tempRef}: ${extractErrorMessage(err)}`);
+      }
+    }
+  }
+}
+async function upsertBranchRef({
+  octokit,
+  owner,
+  repo,
+  branch,
+  sha,
+  force
+}) {
+  try {
+    await octokit.git.updateRef({
+      owner,
+      repo,
+      ref: `heads/${branch}`,
+      sha,
+      force
+    });
+  } catch (err) {
+    if (isNotFoundError(err)) {
+      await octokit.git.createRef({
+        owner,
+        repo,
+        ref: `refs/heads/${branch}`,
+        sha
+      });
+      return;
+    }
+    throw err;
+  }
+}
+async function syncLocalToSignedCommit({
+  repository,
+  branch,
+  signedSha
+}) {
+  await repository.fetch(["origin", branch]);
+  await repository.resetHardToSha(signedSha);
+}
+function hasNumericStatus(err) {
+  return typeof err === "object" && err != null && "status" in err && typeof err.status === "number";
+}
+function isNotFoundError(err) {
+  return hasNumericStatus(err) && err.status === 404;
+}
+function isNonFastForwardError(err) {
+  if (!hasNumericStatus(err) || err.status !== 422) {
+    return false;
+  }
+  const message = extractErrorMessage(err).toLowerCase();
+  return message.includes("not a fast forward") || message.includes("not a fast-forward") || message.includes("update is not a fast forward");
+}
+
+// src/pipeline/replay-summary.ts
+function plural(n, word) {
+  return `${n} ${word}${n === 1 ? "" : "s"}`;
+}
+function formatConflictReason(reason) {
+  switch (reason) {
+    case "same-line-edit":
+      return "The new generation changed the same lines you edited";
+    case "new-file-both":
+      return "Both the generator and your customization created this file";
+    case "base-generation-mismatch":
+      return "This customization was from a previous generation";
+    case "patch-apply-failed":
+      return "The customization could not be applied to the new code";
+    default:
+      return "Your edit overlaps with changes in the new generation";
+  }
+}
+function patchDescription(detail) {
+  if (detail.patchMessage && detail.patchMessage !== "update") {
+    return detail.patchMessage;
+  }
+  const firstFile = detail.files[0];
+  return firstFile != null ? `changes in ${firstFile}` : "customization";
+}
+function logReplaySummary(result, logger) {
+  if (!result.executed) {
+    return;
+  }
+  const applied = result.patchesApplied ?? 0;
+  const absorbed = result.patchesAbsorbed ?? 0;
   const unresolvedCount = result.unresolvedPatches?.length ?? 0;
   const preserved = applied - absorbed;
   logger.debug(
@@ -10288,16 +12098,6 @@ function formatReplayPrBody(result, options) {
   return parts.join("\n");
 }
 
-// src/pipeline/steps/BaseStep.ts
-var BaseStep = class {
-  constructor(outputDir, logger) {
-    this.outputDir = outputDir;
-    this.logger = logger;
-  }
-  outputDir;
-  logger;
-};
-
 // src/pipeline/steps/GithubStep.ts
 var GithubStep = class extends BaseStep {
   constructor(outputDir, logger, config) {
@@ -10407,7 +12207,7 @@ var GithubStep = class extends BaseStep {
       await repository.commitAllChanges(finalCommitMessage2);
       this.logger.debug(`Committed changes to local copy of GitHub repository at ${this.outputDir}`);
     }
-    if (this.config.automationMode) {
+    if (shouldCheckNoDiff(this.config)) {
       const noDiff = await repository.treeHashEquals(`origin/${baseBranch}`);
       if (noDiff) {
         this.logger.info("No changes detected after generation \u2014 skipping PR creation");
@@ -10418,13 +12218,17 @@ var GithubStep = class extends BaseStep {
       executed: true,
       success: true,
       updatedExistingPr: isUpdatingExistingPR
-    };
-    if (!this.config.previewMode) {
-      if (isUpdatingExistingPR) {
-        await repository.forcePush();
-      } else {
-        await repository.push();
-      }
+    };
+    if (!this.config.previewMode) {
+      await pushSignedCommit({
+        repository,
+        octokit,
+        owner,
+        repo,
+        branch: prBranch,
+        force: isUpdatingExistingPR,
+        logger: this.logger
+      });
       const pushedBranch = await repository.getCurrentBranch();
       result.branchUrl = `https://github.com/${this.config.uri}/tree/${pushedBranch}`;
       this.logger.info(`Pushed branch: ${result.branchUrl}`);
@@ -10525,7 +12329,7 @@ var GithubStep = class extends BaseStep {
     const finalCommitMessage = this.config.commitMessage ?? "SDK Generation";
     await repository.commitAllChanges(finalCommitMessage);
     this.logger.debug(`Committed changes to local copy of GitHub repository at ${this.outputDir}`);
-    if (this.config.automationMode) {
+    if (shouldCheckNoDiff(this.config)) {
       const noDiff = await repository.treeHashEquals(`origin/${baseBranch}`);
       if (noDiff) {
         this.logger.info("No changes detected after generation \u2014 skipping push");
@@ -10537,7 +12341,18 @@ var GithubStep = class extends BaseStep {
       success: true
     };
     if (!this.config.previewMode) {
-      await repository.pushWithRebasingRemote();
+      const octokit = new import_rest2.Octokit({ auth: this.config.token });
+      const { owner, repo } = parseRepository(this.config.uri);
+      await pushSignedCommit({
+        repository,
+        octokit,
+        owner,
+        repo,
+        branch: baseBranch,
+        force: false,
+        rebaseOnConflict: true,
+        logger: this.logger
+      });
       const pushedBranch = await repository.getCurrentBranch();
       result.branchUrl = `https://github.com/${this.config.uri}/tree/${pushedBranch}`;
       this.logger.info(`Pushed branch: ${result.branchUrl}`);
@@ -10546,13 +12361,13 @@ var GithubStep = class extends BaseStep {
   }
   async ensureFernignore() {
     this.logger.debug("Checking for .fernignore file...");
-    const fernignorePath = (0, import_path3.join)(this.outputDir, ".fernignore");
+    const fernignorePath = (0, import_path7.join)(this.outputDir, ".fernignore");
     try {
-      await (0, import_promises2.access)(fernignorePath);
+      await (0, import_promises5.access)(fernignorePath);
       this.logger.debug(".fernignore already exists");
     } catch {
       this.logger.debug("Creating .fernignore file...");
-      await (0, import_promises2.writeFile)(fernignorePath, "# Specify files that shouldn't be modified by Fern\n", "utf-8");
+      await (0, import_promises5.writeFile)(fernignorePath, "# Specify files that shouldn't be modified by Fern\n", "utf-8");
     }
   }
   deriveSkipCommit(replayResult) {
@@ -10596,6 +12411,9 @@ _Fern Run ID: \`${config.runId}\`_`;
 function shouldEnableAutomerge(config) {
   return config.automationMode === true && config.autoMerge === true && config.hasBreakingChanges !== true;
 }
+function shouldCheckNoDiff(config) {
+  return config.skipIfNoDiff === true;
+}
 function shouldPushGenerationBaseTag(replayResult) {
   return (replayResult?.patchesWithConflicts ?? 0) > 0;
 }
@@ -10616,242 +12434,6 @@ function resolveBranchAction({
   return "create-from-head";
 }
 
-// src/replay/replay-run.ts
-var import_replay = require("@fern-api/replay");
-var import_child_process3 = require("child_process");
-var import_fs3 = require("fs");
-var import_path5 = require("path");
-
-// src/replay/fernignore.ts
-var import_fs2 = require("fs");
-var import_promises3 = require("fs/promises");
-var import_path4 = require("path");
-var REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml", ".gitattributes"];
-var GITATTRIBUTES_ENTRIES = [".fern/replay.lock linguist-generated=true"];
-async function ensureReplayFernignoreEntries(outputDir) {
-  const fernignorePath = (0, import_path4.join)(outputDir, ".fernignore");
-  let content = "";
-  try {
-    content = await (0, import_promises3.readFile)(fernignorePath, "utf-8");
-  } catch {
-  }
-  const lines = content.split("\n");
-  const toAdd = REPLAY_FERNIGNORE_ENTRIES.filter((entry) => !lines.some((line) => line.trim() === entry));
-  if (toAdd.length > 0) {
-    const suffix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
-    await (0, import_promises3.writeFile)(fernignorePath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
-    return true;
-  }
-  return false;
-}
-async function ensureGitattributesEntries(outputDir) {
-  const gitattributesPath = (0, import_path4.join)(outputDir, ".gitattributes");
-  let content = "";
-  try {
-    content = await (0, import_promises3.readFile)(gitattributesPath, "utf-8");
-  } catch {
-  }
-  const lines = content.split("\n");
-  const toAdd = GITATTRIBUTES_ENTRIES.filter((entry) => !lines.some((line) => line.trim() === entry));
-  if (toAdd.length > 0) {
-    const suffix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
-    await (0, import_promises3.writeFile)(gitattributesPath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
-  }
-}
-function ensureReplayFernignoreEntriesSync(outputDir) {
-  const fernignorePath = (0, import_path4.join)(outputDir, ".fernignore");
-  let content = "";
-  if ((0, import_fs2.existsSync)(fernignorePath)) {
-    content = (0, import_fs2.readFileSync)(fernignorePath, "utf-8");
-  }
-  const lines = content.split("\n");
-  const toAdd = REPLAY_FERNIGNORE_ENTRIES.filter((entry) => !lines.some((line) => line.trim() === entry));
-  if (toAdd.length > 0) {
-    const suffix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
-    (0, import_fs2.writeFileSync)(fernignorePath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
-  }
-}
-function ensureGitattributesEntriesSync(outputDir) {
-  const gitattributesPath = (0, import_path4.join)(outputDir, ".gitattributes");
-  let content = "";
-  if ((0, import_fs2.existsSync)(gitattributesPath)) {
-    content = (0, import_fs2.readFileSync)(gitattributesPath, "utf-8");
-  }
-  const lines = content.split("\n");
-  const toAdd = GITATTRIBUTES_ENTRIES.filter((entry) => !lines.some((line) => line.trim() === entry));
-  if (toAdd.length > 0) {
-    const suffix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
-    (0, import_fs2.writeFileSync)(gitattributesPath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
-  }
-}
-
-// src/replay/replay-run.ts
-async function replayRun(params) {
-  const {
-    outputDir,
-    cliVersion,
-    generatorVersions,
-    stageOnly = false,
-    generatorName,
-    skipApplication,
-    logger
-  } = params;
-  const lockfilePath = (0, import_path5.join)(outputDir, ".fern", "replay.lock");
-  if (!(0, import_fs3.existsSync)(lockfilePath)) {
-    return {
-      report: null,
-      fernignoreUpdated: false,
-      previousGenerationSha: null,
-      currentGenerationSha: null,
-      baseBranchHead: null
-    };
-  }
-  const baseBranchHead = gitRevParse(outputDir, "HEAD");
-  let previousGenerationSha = null;
-  let prevBaseBranchHead = null;
-  try {
-    const lockManager = new import_replay.LockfileManager(outputDir);
-    if (lockManager.exists()) {
-      const lock = lockManager.read();
-      previousGenerationSha = lock.current_generation;
-      const latestGen = lock.generations.find((g2) => g2.commit_sha === lock.current_generation);
-      prevBaseBranchHead = latestGen?.base_branch_head ?? null;
-    }
-  } catch {
-  }
-  if (previousGenerationSha != null) {
-    const sanitizedName = generatorName?.replace(/\//g, "--");
-    const namespacedTag = sanitizedName != null ? `fern-generation-base--${sanitizedName}` : null;
-    const tagSha = (namespacedTag != null ? gitRevParse(outputDir, namespacedTag) : null) ?? gitRevParse(outputDir, "fern-generation-base");
-    let shouldSync = false;
-    if (tagSha != null) {
-      const tagParent = gitRevParse(outputDir, `${tagSha}^`);
-      if (tagParent === prevBaseBranchHead || tagParent === previousGenerationSha) {
-        const tagDistance = gitDiffNameOnly(outputDir, tagSha, "HEAD").length;
-        const lockDistance = gitDiffNameOnly(
-          outputDir,
-          prevBaseBranchHead ?? previousGenerationSha,
-          "HEAD"
-        ).length;
-        shouldSync = tagDistance < lockDistance;
-      }
-    }
-    if (shouldSync && tagSha != null) {
-      if (!isTagMergedIntoHead(outputDir, tagSha)) {
-        logger?.warn(
-          `fern-generation-base tag ${tagSha} is not reachable from HEAD \u2014 skipping divergent-merge sync. The tag likely points at an unmerged generation (PR closed without merge).`
-        );
-      } else {
-        const syncService = new import_replay.ReplayService(outputDir, { enabled: true });
-        await syncService.syncFromDivergentMerge(tagSha, {
-          cliVersion,
-          generatorVersions,
-          baseBranchHead: baseBranchHead ?? void 0
-        });
-        try {
-          const freshLockManager = new import_replay.LockfileManager(outputDir);
-          if (freshLockManager.exists()) {
-            previousGenerationSha = freshLockManager.read().current_generation;
-          }
-        } catch {
-        }
-      }
-    }
-  }
-  const service = new import_replay.ReplayService(outputDir, {
-    enabled: true
-  });
-  let report;
-  try {
-    report = await service.runReplay({
-      cliVersion,
-      generatorVersions,
-      stageOnly,
-      skipApplication,
-      baseBranchHead: baseBranchHead ?? void 0
-    });
-  } catch (error) {
-    logger?.warn("Replay failed, continuing without replay: " + String(error));
-    return {
-      report: null,
-      fernignoreUpdated: false,
-      previousGenerationSha,
-      currentGenerationSha: null,
-      baseBranchHead
-    };
-  }
-  let currentGenerationSha = null;
-  let resolvedBaseBranchHead = baseBranchHead;
-  try {
-    const freshLockManager = new import_replay.LockfileManager(outputDir);
-    if (freshLockManager.exists()) {
-      const freshLock = freshLockManager.read();
-      currentGenerationSha = freshLock.current_generation;
-      const latestGen = freshLock.generations.find((g2) => g2.commit_sha === freshLock.current_generation);
-      if (latestGen?.base_branch_head) {
-        resolvedBaseBranchHead = latestGen.base_branch_head;
-      }
-    }
-  } catch {
-  }
-  const fernignoreUpdated = await ensureReplayFernignoreEntries(outputDir);
-  await ensureGitattributesEntries(outputDir);
-  return {
-    report,
-    fernignoreUpdated,
-    previousGenerationSha,
-    currentGenerationSha,
-    baseBranchHead: resolvedBaseBranchHead
-  };
-}
-function isTagMergedIntoHead(cwd2, tagSha) {
-  try {
-    (0, import_child_process3.execFileSync)("git", ["merge-base", "--is-ancestor", tagSha, "HEAD"], {
-      cwd: cwd2,
-      stdio: "pipe"
-    });
-    return true;
-  } catch {
-  }
-  const tagTree = gitRevParse(cwd2, `${tagSha}^{tree}`);
-  if (tagTree == null) {
-    return false;
-  }
-  try {
-    const trees = (0, import_child_process3.execFileSync)("git", ["log", "HEAD", "--format=%T", "--max-count=500"], {
-      cwd: cwd2,
-      encoding: "utf-8",
-      stdio: "pipe"
-    });
-    return trees.split("\n").some((t2) => t2.trim() === tagTree);
-  } catch {
-    return false;
-  }
-}
-function gitRevParse(cwd2, rev) {
-  try {
-    return (0, import_child_process3.execFileSync)("git", ["rev-parse", "--verify", rev], {
-      cwd: cwd2,
-      encoding: "utf-8",
-      stdio: "pipe"
-    }).trim();
-  } catch {
-    return null;
-  }
-}
-function gitDiffNameOnly(cwd2, from, to) {
-  try {
-    const output = (0, import_child_process3.execFileSync)("git", ["diff", "--name-only", from, to], {
-      cwd: cwd2,
-      encoding: "utf-8",
-      stdio: "pipe"
-    });
-    return output.trim().split("\n").filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-
 // src/pipeline/steps/ReplayStep.ts
 var ReplayStep = class extends BaseStep {
   constructor(outputDir, logger, config, cliVersion, generatorVersions, generatorName) {
@@ -10866,8 +12448,23 @@ var ReplayStep = class extends BaseStep {
   generatorVersions;
   generatorName;
   name = "replay";
-  async execute(_context) {
-    const result = await replayRun({
+  async execute(context) {
+    const generationCommit = context.previousStepResults.generationCommit;
+    const prepared = generationCommit?.preparedReplay;
+    if (generationCommit != null && prepared == null) {
+      return {
+        executed: true,
+        success: true,
+        flow: "first-generation",
+        patchesDetected: 0,
+        patchesApplied: 0,
+        patchesWithConflicts: 0
+      };
+    }
+    const result = prepared != null ? await replayApply(prepared, {
+      stageOnly: this.config.stageOnly ?? false,
+      logger: this.logger
+    }) : await replayRun({
       outputDir: this.outputDir,
       cliVersion: this.cliVersion,
       generatorVersions: this.generatorVersions,
@@ -10923,13 +12520,34 @@ var PostGenerationPipeline = class {
   constructor(config, logger = consolePipelineLogger) {
     this.config = config;
     this.logger = logger;
-    if (config.replay?.enabled && config.github?.mode === "push") {
+    let replayEnabled = config.replay?.enabled ?? false;
+    let autoVersionEnabled = config.autoVersion?.enabled ?? false;
+    if (replayEnabled && config.github?.mode === "push") {
       this.logger.warn(
         "Replay is not supported with GitHub push mode. Disabling replay to prevent force push to base branch."
       );
-      config.replay.enabled = false;
+      replayEnabled = false;
+    }
+    if (autoVersionEnabled && !replayEnabled) {
+      this.logger.warn("AutoVersion requires Replay to be enabled. Disabling AutoVersion for this run.");
+      autoVersionEnabled = false;
+    }
+    if (replayEnabled && config.replay != null) {
+      this.steps.push(
+        new GenerationCommitStep(
+          config.outputDir,
+          this.logger,
+          { enabled: true, skipApplication: config.replay.skipApplication },
+          config.cliVersion,
+          config.generatorVersions,
+          config.generatorName
+        )
+      );
     }
-    if (config.replay?.enabled) {
+    if (autoVersionEnabled && config.autoVersion != null) {
+      this.steps.push(new AutoVersionStep(config.outputDir, this.logger, config.autoVersion));
+    }
+    if (replayEnabled && config.replay != null) {
       this.steps.push(
         new ReplayStep(
           config.outputDir,
@@ -10951,8 +12569,8 @@ var PostGenerationPipeline = class {
   async run() {
     if (this.config.github?.enabled) {
       try {
-        (0, import_child_process4.execFileSync)("git", ["config", "user.name", FERN_BOT_NAME], { cwd: this.config.outputDir });
-        (0, import_child_process4.execFileSync)("git", ["config", "user.email", FERN_BOT_EMAIL], { cwd: this.config.outputDir });
+        (0, import_child_process5.execFileSync)("git", ["config", "user.name", FERN_BOT_NAME], { cwd: this.config.outputDir });
+        (0, import_child_process5.execFileSync)("git", ["config", "user.email", FERN_BOT_EMAIL], { cwd: this.config.outputDir });
       } catch {
       }
     }
@@ -10966,9 +12584,15 @@ var PostGenerationPipeline = class {
     for (const step of this.steps) {
       try {
         const stepResult = await step.execute(pipelineContext);
-        if (step.name === "replay") {
+        if (step.name === "generationCommit") {
+          result.steps.generationCommit = stepResult;
+          pipelineContext.previousStepResults.generationCommit = stepResult;
+        } else if (step.name === "replay") {
           result.steps.replay = stepResult;
           pipelineContext.previousStepResults.replay = stepResult;
+        } else if (step.name === "autoVersion") {
+          result.steps.autoVersion = stepResult;
+          pipelineContext.previousStepResults.autoVersion = stepResult;
         } else if (step.name === "fernignore") {
           result.steps.fernignore = stepResult;
         } else if (step.name === "github") {
@@ -10998,8 +12622,8 @@ function replayForget(params) {
 
 // src/replay/replay-init.ts
 var import_replay3 = require("@fern-api/replay");
-var import_fs4 = require("fs");
-var import_path6 = require("path");
+var import_fs6 = require("fs");
+var import_path8 = require("path");
 var import_tmp_promise2 = __toESM(require("tmp-promise"));
 async function replayInit(params) {
   const { githubRepo, token, dryRun } = params;
@@ -11025,10 +12649,10 @@ async function replayInit(params) {
   }
   ensureReplayFernignoreEntriesSync(repoPath);
   ensureGitattributesEntriesSync(repoPath);
-  const lockfilePath = (0, import_path6.join)(repoPath, ".fern", "replay.lock");
-  const lockfileContent = (0, import_fs4.existsSync)(lockfilePath) ? (0, import_fs4.readFileSync)(lockfilePath, "utf-8") : void 0;
-  const replayYmlPath = (0, import_path6.join)(repoPath, ".fern", "replay.yml");
-  const replayYmlContent = (0, import_fs4.existsSync)(replayYmlPath) ? (0, import_fs4.readFileSync)(replayYmlPath, "utf-8") : void 0;
+  const lockfilePath = (0, import_path8.join)(repoPath, ".fern", "replay.lock");
+  const lockfileContent = (0, import_fs6.existsSync)(lockfilePath) ? (0, import_fs6.readFileSync)(lockfilePath, "utf-8") : void 0;
+  const replayYmlPath = (0, import_path8.join)(repoPath, ".fern", "replay.yml");
+  const replayYmlContent = (0, import_fs6.existsSync)(replayYmlPath) ? (0, import_fs6.readFileSync)(replayYmlPath, "utf-8") : void 0;
   return {
     bootstrap: bootstrapResult,
     lockfileContent,
@@ -11156,9 +12780,66 @@ var import_replay5 = require("@fern-api/replay");
 function replayStatus(params) {
   return (0, import_replay5.status)(params.outputDir);
 }
+
+// src/replay/replay-submit-init.ts
+async function submitReplayInit(params) {
+  const { fiddleOrigin, fernToken, githubRepo, initResult } = params;
+  const { owner, repo } = parseOwnerRepo(githubRepo);
+  const response = await fetch(`${fiddleOrigin}/api/remote-gen/replay/init`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${fernToken}`
+    },
+    body: JSON.stringify({
+      owner,
+      repo,
+      lockfileContents: initResult.lockfileContent,
+      fernignoreEntries: initResult.fernignoreEntries,
+      prBody: initResult.prBody
+    })
+  });
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new ReplaySubmitError(
+        "The Fern GitHub App is not installed on this repository. Install it at https://github.com/apps/fern-api to enable server-side PR creation.",
+        response.status
+      );
+    }
+    const body = await response.text();
+    throw new ReplaySubmitError(`Failed to create PR via Fern: ${body}`, response.status);
+  }
+  const data = await response.json();
+  if (!isSubmitResponse(data)) {
+    throw new ReplaySubmitError("Unexpected response from Fern: missing prUrl field.");
+  }
+  return { prUrl: data.prUrl };
+}
+function parseOwnerRepo(githubRepo) {
+  const cleaned = githubRepo.replace(/^https?:\/\//, "").replace(/\.git$/, "").replace(/^github\.com\//, "");
+  const parts = cleaned.split("/");
+  const owner = parts[parts.length - 2];
+  const repo = parts[parts.length - 1];
+  if (!owner || !repo) {
+    throw new Error(`Could not parse owner/repo from: ${githubRepo}`);
+  }
+  return { owner, repo };
+}
+var ReplaySubmitError = class extends Error {
+  statusCode;
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "ReplaySubmitError";
+    this.statusCode = statusCode;
+  }
+};
+function isSubmitResponse(data) {
+  return typeof data === "object" && data != null && "prUrl" in data && typeof data.prUrl === "string";
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PostGenerationPipeline,
+  ReplaySubmitError,
   consolePipelineLogger,
   formatBootstrapSummary,
   formatReplayPrBody,
@@ -11170,9 +12851,11 @@ function replayStatus(params) {
   githubPush,
   githubRelease,
   logReplaySummary,
+  parseOwnerRepo,
   replayForget,
   replayInit,
   replayResolve,
   replayRun,
-  replayStatus
+  replayStatus,
+  submitReplayInit
 });