@fern-api/generator-cli 0.9.11 → 0.9.14

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;
         }
@@ -10060,46 +10060,1662 @@ 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/BaseStep.ts
-var BaseStep = class {
-  constructor(outputDir, logger) {
-    this.outputDir = outputDir;
-    this.logger = logger;
+// 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");
+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;
+    }
   }
-  outputDir;
-  logger;
 };
-
-// src/pipeline/steps/AutoVersionStep.ts
-var AutoVersionStep = class extends BaseStep {
-  constructor(outputDir, logger, config) {
+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 (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;
+      }
+    }
+    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}`
+      );
+      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;
+        }
+      }
+    }
+    this.logger.warn(`No matching minus line found after scanning ${linesScanned} lines backwards`);
+    return void 0;
+  }
+  /**
+   * 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);
+      }
+    }
+    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");
+  }
+  /**
+   * 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);
+    }
+    if (currentChunkTexts.length > 0) {
+      chunks.push(currentChunkTexts.join("\n"));
+    }
+    return chunks;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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;
-  name = "autoVersion";
+  cliVersion;
+  generatorVersions;
+  generatorName;
+  name = "generationCommit";
   async execute(_context) {
-    this.logger.info(
-      `AutoVersionStep: no-op scaffold for language=${this.config.language} (logic lands in FER-9980)`
-    );
+    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
+      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_promises2 = require("fs/promises");
-var import_path3 = require("path");
+var import_promises5 = require("fs/promises");
+var import_path7 = require("path");
 
 // src/pipeline/github/createReplayBranch.ts
 async function createReplayBranch(repository, branchName, commitMessage, replayConflictInfo, logger) {
@@ -10745,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) {
@@ -10818,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) {
@@ -11068,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,
@@ -11125,16 +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.autoVersion?.enabled) {
+    if (autoVersionEnabled && config.autoVersion != null) {
       this.steps.push(new AutoVersionStep(config.outputDir, this.logger, config.autoVersion));
     }
-    if (config.replay?.enabled) {
+    if (replayEnabled && config.replay != null) {
       this.steps.push(
         new ReplayStep(
           config.outputDir,
@@ -11156,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 {
       }
     }
@@ -11171,7 +12584,12 @@ var PostGenerationPipeline = class {
     for (const step of this.steps) {
       try {
         const stepResult = await step.execute(pipelineContext);
-        if (step.name === "replay") {
+        if (step.name === "generationCommit") {
+          const gcResult = stepResult;
+          const { preparedReplay: _preparedReplay, ...serializable } = gcResult;
+          result.steps.generationCommit = serializable;
+          pipelineContext.previousStepResults.generationCommit = gcResult;
+        } else if (step.name === "replay") {
           result.steps.replay = stepResult;
           pipelineContext.previousStepResults.replay = stepResult;
         } else if (step.name === "autoVersion") {
@@ -11206,8 +12624,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;
@@ -11233,10 +12651,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,