@fern-api/replay 0.19.0 → 0.19.1

package/dist/index.d.cts

@@ -970,6 +970,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

@@ -970,6 +970,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",
@@ -3856,7 +3903,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 +3961,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 +4001,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