@fern-api/replay 0.19.1 → 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

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

package/dist/index.js

@@ -3245,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];
@@ -3383,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();
@@ -3621,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