@fern-api/replay 0.19.0 → 0.19.2

package/dist/index.d.cts

@@ -884,6 +884,31 @@ declare class ReplayService {
      */
     getLastResults(): ReadonlyArray<ReplayResult>;
     constructor(outputDir: string, _config: ReplayConfig);
+    /**
+     * Resolve the previous-generation SHA to export on
+     * `ReplayPreparation.previousGenerationSha`.
+     *
+     * `current_generation` is the SHA of a LOCALLY-created `[fern-generated]` commit.
+     * generator-cli's signed-commit push (`pushSignedCommit`) recreates that commit under a
+     * new remote SHA, and a squash-merge collapses it away, so the recorded value can be
+     * unreachable in a later clone (org "Natural": autoVersion then diffed against a phantom
+     * baseline and silently reported NO_CHANGE — or, pre-a38bbc6, shipped
+     * `0.0.0-fern-placeholder`). Consumers (generator-cli's autoVersion) diff against this
+     * baseline, so it MUST resolve to a real commit.
+     *
+     * Prefer the recorded SHA while it still resolves — the healthy case, and the pristine
+     * prior `[fern-generated]` tree. Otherwise re-anchor on the most recent reachable
+     * generation boundary in first-parent history: the SAME value the detector already
+     * derives for its own scan boundary (`findPreviousGenerationFromHistory`, whose
+     * `isGenerationBoundary` matches squash-merge subjects like `SDK Generation (#N)`). Fall
+     * back to the recorded SHA only when no boundary is reachable at all — no worse than the
+     * prior behavior. ADR 0002 (generator-cli) allows replay to expose this reconciled value;
+     * the consumer stays independently resilient.
+     *
+     * MUST be called before the new `[fern-generated]` commit is created, while HEAD is still
+     * the pre-generation (customer) state, so the walk anchors on the PREVIOUS generation.
+     */
+    resolveReachablePreviousGeneration(recordedSha: string | null): Promise<string | null>;
     /**
      * Phase 1 of the two-phase replay flow. Runs preGenerationRebase (when applicable),
      * detects new patches, and creates the `[fern-generated]` commit. Leaves HEAD at
@@ -970,6 +995,21 @@ declare class ReplayService {
      * never be used during apply anyway).
      */
     private readSnapshotFromDisk;
+    /**
+     * Autoversion-aware replacement for the naive `git diff currentGen -- files`
+     * + on-disk snapshot used when rebasing a cleanly-applied patch.
+     *
+     * The generation tree (BASE) still carries the placeholder on version lines
+     * (autoversion runs after `[fern-generated]`), but the working tree holds
+     * autoversion's resolved semver. A raw diff/snapshot would fold the
+     * placeholder->semver swap into the customer's patch_content/theirs_snapshot,
+     * pinning a stale version. This re-derives both against a version-neutralized
+     * THEIRS so the pipeline-owned version line never enters the patch.
+     *
+     * Returns null when no file is under autoversion (fixed `--version`, i.e. no
+     * placeholder in the generation tree) — callers keep their existing behavior.
+     */
+    private computeAutoversionNeutralizedRebase;
     /**
      * Detects autoversion contamination — returns true when a
      * `[fern-autoversion]` commit between `fromSha` and `toSha` touched any

package/dist/index.d.ts

@@ -884,6 +884,31 @@ declare class ReplayService {
      */
     getLastResults(): ReadonlyArray<ReplayResult>;
     constructor(outputDir: string, _config: ReplayConfig);
+    /**
+     * Resolve the previous-generation SHA to export on
+     * `ReplayPreparation.previousGenerationSha`.
+     *
+     * `current_generation` is the SHA of a LOCALLY-created `[fern-generated]` commit.
+     * generator-cli's signed-commit push (`pushSignedCommit`) recreates that commit under a
+     * new remote SHA, and a squash-merge collapses it away, so the recorded value can be
+     * unreachable in a later clone (org "Natural": autoVersion then diffed against a phantom
+     * baseline and silently reported NO_CHANGE — or, pre-a38bbc6, shipped
+     * `0.0.0-fern-placeholder`). Consumers (generator-cli's autoVersion) diff against this
+     * baseline, so it MUST resolve to a real commit.
+     *
+     * Prefer the recorded SHA while it still resolves — the healthy case, and the pristine
+     * prior `[fern-generated]` tree. Otherwise re-anchor on the most recent reachable
+     * generation boundary in first-parent history: the SAME value the detector already
+     * derives for its own scan boundary (`findPreviousGenerationFromHistory`, whose
+     * `isGenerationBoundary` matches squash-merge subjects like `SDK Generation (#N)`). Fall
+     * back to the recorded SHA only when no boundary is reachable at all — no worse than the
+     * prior behavior. ADR 0002 (generator-cli) allows replay to expose this reconciled value;
+     * the consumer stays independently resilient.
+     *
+     * MUST be called before the new `[fern-generated]` commit is created, while HEAD is still
+     * the pre-generation (customer) state, so the walk anchors on the PREVIOUS generation.
+     */
+    resolveReachablePreviousGeneration(recordedSha: string | null): Promise<string | null>;
     /**
      * Phase 1 of the two-phase replay flow. Runs preGenerationRebase (when applicable),
      * detects new patches, and creates the `[fern-generated]` commit. Leaves HEAD at
@@ -970,6 +995,21 @@ declare class ReplayService {
      * never be used during apply anyway).
      */
     private readSnapshotFromDisk;
+    /**
+     * Autoversion-aware replacement for the naive `git diff currentGen -- files`
+     * + on-disk snapshot used when rebasing a cleanly-applied patch.
+     *
+     * The generation tree (BASE) still carries the placeholder on version lines
+     * (autoversion runs after `[fern-generated]`), but the working tree holds
+     * autoversion's resolved semver. A raw diff/snapshot would fold the
+     * placeholder->semver swap into the customer's patch_content/theirs_snapshot,
+     * pinning a stale version. This re-derives both against a version-neutralized
+     * THEIRS so the pipeline-owned version line never enters the patch.
+     *
+     * Returns null when no file is under autoversion (fixed `--version`, i.e. no
+     * placeholder in the generation tree) — callers keep their existing behavior.
+     */
+    private computeAutoversionNeutralizedRebase;
     /**
      * Detects autoversion contamination — returns true when a
      * `[fern-autoversion]` commit between `fromSha` and `toSha` touched any

package/dist/index.js

@@ -2027,6 +2027,51 @@ async function buildMergePlan(args) {
 // src/applicator/runMergeAndRecord.ts
 import { mkdir, writeFile } from "fs/promises";
 import { dirname as dirname2 } from "path";
+
+// src/autoversion.ts
+var AUTOVERSION_PLACEHOLDERS = [
+  "v0.0.0-fern-placeholder",
+  // Go -- a superstring of the default; check first
+  "0.0.0-fern-placeholder",
+  // TS/Java/C#/Ruby/PHP/Rust/default
+  "0.0.0.dev0"
+  // Python (PEP 440 -- Poetry rejects hyphens)
+];
+var VERSION_TOKEN = /(?:v)?\d+\.\d+\.\d+[0-9A-Za-z.+-]*/g;
+var VERSION_MASK = "@@FERN_VERSION@@";
+function maskVersions(line) {
+  return line.replace(VERSION_TOKEN, VERSION_MASK);
+}
+function containsPlaceholder(content) {
+  if (!content) return false;
+  return AUTOVERSION_PLACEHOLDERS.some((p) => content.includes(p));
+}
+function remapManagedLines(genBase, target, theirs) {
+  if (!containsPlaceholder(genBase)) return theirs;
+  const managedMasks = /* @__PURE__ */ new Set();
+  for (const line of genBase.split("\n")) {
+    if (AUTOVERSION_PLACEHOLDERS.some((p) => line.includes(p))) managedMasks.add(maskVersions(line));
+  }
+  if (managedMasks.size === 0) return theirs;
+  const targetByMask = /* @__PURE__ */ new Map();
+  for (const line of target.split("\n")) {
+    const mask = maskVersions(line);
+    if (managedMasks.has(mask) && !targetByMask.has(mask)) targetByMask.set(mask, line);
+  }
+  return theirs.split("\n").map((line) => {
+    const mask = maskVersions(line);
+    const replacement = managedMasks.has(mask) ? targetByMask.get(mask) : void 0;
+    return replacement !== void 0 && replacement !== line ? replacement : line;
+  }).join("\n");
+}
+function neutralizeAutoversionTheirs(genBase, theirs) {
+  return remapManagedLines(genBase, genBase, theirs);
+}
+function alignAutoversionToOurs(genBase, ours, theirs) {
+  return remapManagedLines(genBase, ours, theirs);
+}
+
+// src/applicator/runMergeAndRecord.ts
 async function runMergeAndRecord(args) {
   const { plan, inputs, patch, accumulator } = args;
   const { resolvedPath, metadata, oursPath, ours } = inputs;
@@ -2057,11 +2102,13 @@ async function runMergeAndRecord(args) {
     accumulator.recordMerge(resolvedPath, merged2.content, patch.base_generation);
     return { file: resolvedPath, status: "merged", ...unreachableFlag };
   }
-  const merged = threeWayMerge(plan.mergeBase, ours, plan.theirs);
+  const mergeBase = inputs.base != null ? alignAutoversionToOurs(inputs.base, ours, plan.mergeBase) : plan.mergeBase;
+  const theirs = inputs.base != null ? alignAutoversionToOurs(inputs.base, ours, plan.theirs) : plan.theirs;
+  const merged = threeWayMerge(mergeBase, ours, theirs);
   await mkdir(dirname2(oursPath), { recursive: true });
   await writeFile(oursPath, merged.content);
   if (merged.hasConflicts) {
-    accumulator.recordConflict(resolvedPath, plan.theirs, patch.base_generation);
+    accumulator.recordConflict(resolvedPath, theirs, patch.base_generation);
     return {
       file: resolvedPath,
       status: "conflict",
@@ -2070,7 +2117,7 @@ async function runMergeAndRecord(args) {
       conflictMetadata: metadata
     };
   }
-  accumulator.recordMerge(resolvedPath, plan.theirs, patch.base_generation);
+  accumulator.recordMerge(resolvedPath, theirs, patch.base_generation);
   return {
     file: resolvedPath,
     status: "merged",
@@ -3198,7 +3245,9 @@ var NoPatchesFlow = class {
   }
   async prepare(options) {
     const preLock = this.service.lockManager.read();
-    const previousGenerationSha = preLock.current_generation ?? null;
+    const previousGenerationSha = await this.service.resolveReachablePreviousGeneration(
+      preLock.current_generation ?? null
+    );
     let { patches: newPatches, revertedPatchIds } = await this.service.detector.detectNewPatches();
     const detectorWarnings = [...this.service.detector.warnings];
     const detectorDegraded = [...this.service.detector.degradedReasons];
@@ -3336,7 +3385,9 @@ var NormalRegenerationFlow = class {
   }
   async prepare(options) {
     const preLock = this.service.lockManager.read();
-    const previousGenerationSha = preLock.current_generation ?? null;
+    const previousGenerationSha = await this.service.resolveReachablePreviousGeneration(
+      preLock.current_generation ?? null
+    );
     if (options?.dryRun) {
       const existingPatches2 = this.service.lockManager.getPatches();
       const { patches: newPatches2, revertedPatchIds: dryRunReverted } = await this.service.detector.detectNewPatches();
@@ -3574,6 +3625,37 @@ var ReplayService = class {
     this.committer = new ReplayCommitter(git, outputDir);
     this.fileOwnership = new FileOwnership(git);
   }
+  /**
+   * Resolve the previous-generation SHA to export on
+   * `ReplayPreparation.previousGenerationSha`.
+   *
+   * `current_generation` is the SHA of a LOCALLY-created `[fern-generated]` commit.
+   * generator-cli's signed-commit push (`pushSignedCommit`) recreates that commit under a
+   * new remote SHA, and a squash-merge collapses it away, so the recorded value can be
+   * unreachable in a later clone (org "Natural": autoVersion then diffed against a phantom
+   * baseline and silently reported NO_CHANGE — or, pre-a38bbc6, shipped
+   * `0.0.0-fern-placeholder`). Consumers (generator-cli's autoVersion) diff against this
+   * baseline, so it MUST resolve to a real commit.
+   *
+   * Prefer the recorded SHA while it still resolves — the healthy case, and the pristine
+   * prior `[fern-generated]` tree. Otherwise re-anchor on the most recent reachable
+   * generation boundary in first-parent history: the SAME value the detector already
+   * derives for its own scan boundary (`findPreviousGenerationFromHistory`, whose
+   * `isGenerationBoundary` matches squash-merge subjects like `SDK Generation (#N)`). Fall
+   * back to the recorded SHA only when no boundary is reachable at all — no worse than the
+   * prior behavior. ADR 0002 (generator-cli) allows replay to expose this reconciled value;
+   * the consumer stays independently resilient.
+   *
+   * MUST be called before the new `[fern-generated]` commit is created, while HEAD is still
+   * the pre-generation (customer) state, so the walk anchors on the PREVIOUS generation.
+   */
+  async resolveReachablePreviousGeneration(recordedSha) {
+    if (recordedSha != null && await this.git.commitExists(recordedSha)) {
+      return recordedSha;
+    }
+    const derived = await this.detector.findPreviousGenerationFromHistory();
+    return derived ?? recordedSha;
+  }
   /**
    * Phase 1 of the two-phase replay flow. Runs preGenerationRebase (when applicable),
    * detects new patches, and creates the `[fern-generated]` commit. Leaves HEAD at
@@ -3856,7 +3938,9 @@ var ReplayService = class {
           if (baseChanged) repointed++;
           continue;
         }
-        const diff = await this.git.exec(["diff", currentGenSha, "--", ...patch.files]).catch(() => null);
+        const rawDiff = await this.git.exec(["diff", currentGenSha, "--", ...patch.files]).catch(() => null);
+        const neutralizedRebase = rawDiff != null && containsPlaceholder(rawDiff) ? await this.computeAutoversionNeutralizedRebase(patch.files, currentGenSha) : null;
+        const diff = neutralizedRebase ? neutralizedRebase.diff : rawDiff;
         if (diff === null) continue;
         if (!diff.trim()) {
           if (hasProtectedFiles) {
@@ -3912,7 +3996,7 @@ var ReplayService = class {
         patch.base_generation = currentGenSha;
         patch.patch_content = diff;
         patch.content_hash = newContentHash;
-        const snapshot = await this.readSnapshotFromDisk(patch.files);
+        const snapshot = neutralizedRebase ? neutralizedRebase.snapshot : await this.readSnapshotFromDisk(patch.files);
         const snapshotIsNonEmpty = Object.keys(snapshot).length > 0;
         if (snapshotIsNonEmpty) {
           patch.theirs_snapshot = snapshot;
@@ -3952,6 +4036,47 @@ var ReplayService = class {
     }
     return snapshot;
   }
+  /**
+   * Autoversion-aware replacement for the naive `git diff currentGen -- files`
+   * + on-disk snapshot used when rebasing a cleanly-applied patch.
+   *
+   * The generation tree (BASE) still carries the placeholder on version lines
+   * (autoversion runs after `[fern-generated]`), but the working tree holds
+   * autoversion's resolved semver. A raw diff/snapshot would fold the
+   * placeholder->semver swap into the customer's patch_content/theirs_snapshot,
+   * pinning a stale version. This re-derives both against a version-neutralized
+   * THEIRS so the pipeline-owned version line never enters the patch.
+   *
+   * Returns null when no file is under autoversion (fixed `--version`, i.e. no
+   * placeholder in the generation tree) — callers keep their existing behavior.
+   */
+  async computeAutoversionNeutralizedRebase(files, currentGenSha) {
+    const genByFile = /* @__PURE__ */ new Map();
+    let anyPlaceholder = false;
+    for (const file of files) {
+      const gen = await this.git.showFile(currentGenSha, file).catch(() => null);
+      genByFile.set(file, gen);
+      if (containsPlaceholder(gen)) anyPlaceholder = true;
+    }
+    if (!anyPlaceholder) return null;
+    const snapshot = {};
+    const fragments = [];
+    for (const file of files) {
+      if (isBinaryFile(file)) continue;
+      const disk = await readFileAsync(join7(this.outputDir, file), "utf-8").catch(() => null);
+      if (disk == null) continue;
+      const gen = genByFile.get(file) ?? null;
+      const neutralized = gen != null ? neutralizeAutoversionTheirs(gen, disk) : disk;
+      snapshot[file] = neutralized;
+      if (gen == null) {
+        fragments.push(synthesizeNewFileDiff(file, neutralized));
+      } else if (gen !== neutralized) {
+        const fileDiff = await unifiedDiff(gen, neutralized, file);
+        if (fileDiff.trim()) fragments.push(fileDiff);
+      }
+    }
+    return { diff: fragments.join(""), snapshot };
+  }
   /**
    * Detects autoversion contamination — returns true when a
    * `[fern-autoversion]` commit between `fromSha` and `toSha` touched any