@fern-api/replay 0.15.0 → 0.15.2

package/dist/index.d.ts

@@ -133,6 +133,16 @@ interface CommitInfo {
 interface ReplayConfig {
     enabled: boolean;
 }
+/**
+ * The four mutually-exclusive code paths a `runReplay()` invocation can take.
+ * Selected by `ReplayService.selectFlow()` based on lockfile state and options.
+ *
+ * - `first-generation` — no lockfile yet; this run creates the initial generation record.
+ * - `no-patches` — lockfile exists with zero patches; only newly detected patches apply.
+ * - `normal-regeneration` — lockfile exists with patches; full pre-rebase + apply + post-rebase pipeline.
+ * - `skip-application` — `--no-replay` mode; commit generation, set replay-skipped marker, return early.
+ */
+type FlowKind = "first-generation" | "no-patches" | "normal-regeneration" | "skip-application";
 
 /**
  * Credential detection patterns for the replay pipeline.
@@ -143,8 +153,6 @@ interface ReplayConfig {
  *
  * These patterns mirror the invariant assertions in __tests__/invariants/i4-credential-containment.ts.
  * If they diverge, the invariant tests independently catch real leaks.
- *
- * @security FER-9807
  */
 interface CredentialPattern {
     name: string;
@@ -253,7 +261,7 @@ declare class ReplayDetector {
     constructor(git: GitClient, lockManager: LockfileManager, sdkOutputDir: string);
     detectNewPatches(): Promise<DetectionResult>;
     /**
-     * FER-10201 — Non-linear-history detection via `merge-base(prevGen, HEAD)`.
+     * Non-linear-history detection via `merge-base(prevGen, HEAD)`.
      *
      * After a squash-merge of a Fern-bot PR, `lastGen.commit_sha` (the previous
      * `[fern-generated]`) is orphaned but still in git's object database. The
@@ -268,7 +276,7 @@ declare class ReplayDetector {
      */
     private detectPatchesViaMergeBase;
     /**
-     * FER-10201 — Walk `${rangeStart}..HEAD`, classify each commit, emit one
+     * Walk `${rangeStart}..HEAD`, classify each commit, emit one
      * `StoredPatch` per customer commit. Body shared by the linear path
      * (rangeStart = lastGen.commit_sha) and the merge-base path.
      *
@@ -292,17 +300,15 @@ declare class ReplayDetector {
      *
      * This ensures content hashes match across the no-patches and normal-
      * regeneration flows, which store formatPatch and git-diff formats
-     * respectively (FER-9850, D5-D9).
+     * respectively.
      */
     computeContentHash(patchContent: string): string;
     /**
-     * FER-9805 — Drop patches whose files were transiently created and then
-     * deleted within the current linear detection window, and are absent from
+     * Drop patches whose files were transiently created and then deleted
+     * within the current linear detection window, and are absent from
      * HEAD at the end of the window.
      *
-     * Rationale: on a merge commit, createMergeCompositePatch already diffs
-     * firstParent..mergeCommit so net-zero files never enter the composite. On
-     * linear history each commit becomes its own patch, so a file that was
+     * Rationale: each commit becomes its own patch, so a file that was
      * briefly added and later removed survives as a create+delete pair whose
      * cumulative diff is empty. We drop such patches before they reach the
      * lockfile.
@@ -322,8 +328,8 @@ declare class ReplayDetector {
      * single files from a multi-file patch would require a follow-up that
      * regenerates the patch content via `git format-patch -- <files>`. No
      * current failing test exercises this, and leaving the patch intact
-     * preserves today's behaviour. TODO(FER-9805): revisit if a future
-     * adversarial test demands per-file stripping.
+     * preserves today's behaviour. Revisit if a future adversarial test
+     * demands per-file stripping.
      */
     private collapseNetZeroFiles;
     /**
@@ -333,13 +339,6 @@ declare class ReplayDetector {
      * more aggressively. On typical SDK repos this is a single sub-10ms call.
      */
     private listHeadFiles;
-    /**
-     * Create a single composite patch for a merge commit by diffing the merge
-     * commit against its first parent. This captures the net change of the
-     * entire merged branch as one patch, eliminating accumulator chaining and
-     * zero-net-change ghost conflicts.
-     */
-    private createMergeCompositePatch;
     /**
      * Detect patches via tree diff for non-linear history. Returns a composite patch.
      * Revert reconciliation is skipped here because tree-diff produces a single composite
@@ -381,46 +380,27 @@ declare class ReplayDetector {
  */
 declare function threeWayMerge(base: string, ours: string, theirs: string): MergeResult;
 
+interface AccumulatorEntry {
+    readonly content: string;
+    readonly baseGeneration: string;
+}
+
 declare class ReplayApplicator {
     private git;
     private lockManager;
     private outputDir;
     private renameCache;
     private treeExistsCache;
-    private fileTheirsAccumulator;
     /**
-     * Apply mode for the current `applyPatches` invocation. Set at the start
-     * of `applyPatches`, read by `mergeFile` to decide:
-     *   - whether to skip the intra-loop marker strip (kept in `applyPatches`)
-     *   - whether to populate the accumulator after a conflicted merge
-     *     (resolve mode populates so subsequent patches on the same file
-     *     can use patch A's THEIRS as a structurally-correct merge base
-     *     when their diff was authored against post-A structure)
-     *   - whether to retry THEIRS reconstruction against the accumulator
-     *     when the BASE-relative reconstruction produced markers from a
-     *     cross-patch context mismatch
-     */
-    private currentApplyMode;
-    /**
-     * Set of files that appear in 2+ patches in the current `applyPatches`
-     * invocation. Computed at the top of `applyPatches`. Read by `mergeFile`
-     * and `populateAccumulatorForPatch` to decide whether to use the patch's
-     * `theirs_snapshot` directly as THEIRS (snapshot-as-primary) or fall
-     * back to line-anchored reconstruction (FER-9525 cross-patch isolation).
+     * Inter-patch THEIRS coordination. Created fresh in each `applyPatches`
+     * invocation with the run's apply mode + precomputed shared-file set.
+     * See `src/accumulator/MergeAccumulator.ts` for the full contract.
      *
-     * Snapshot-as-primary is correct when the patch owns its file (no other
-     * patch in this run touches it): the snapshot is what the customer
-     * intends for that file post-regen, regardless of generator structural
-     * changes that would invalidate the diff's line anchors.
-     *
-     * When a file IS shared, snapshots are CUMULATIVE across the patches
-     * touching it (each one's snapshot includes prior patches' contributions).
-     * Using a later patch's cumulative snapshot as its individual THEIRS
-     * would propagate prior patches' edits into the merge — surfacing nested
-     * conflicts at regions the patch alone never touched. Reconstruction
-     * via `applyPatchToContent` is required there.
+     * Initialized to an empty default in the constructor so type narrowing
+     * works for callers that read it before any `applyPatches` invocation
+     * (e.g., the `getAccumulatorSnapshot` test accessor).
      */
-    private sharedFiles;
+    private accumulator;
     constructor(git: GitClient, lockManager: LockfileManager, outputDir: string);
     /**
      * Resolve the GenerationRecord for a patch's base_generation.
@@ -428,19 +408,14 @@ declare class ReplayApplicator {
      * when base_generation isn't a tracked generation (commit-scan patches).
      */
     private resolveBaseGeneration;
-    /** Reset inter-patch accumulator for a new cycle. */
-    private resetAccumulator;
     /**
      * @internal Test-only.
-     * Returns a defensive copy of the inter-patch accumulator. Used by the
-     * adversarial test suite (FER-9791) to assert invariant I2: after every
-     * applied patch, the accumulator has an entry for each file the patch
-     * touched, and the entry's content matches on-disk.
+     * Returns a defensive copy of the inter-patch accumulator. Used by
+     * invariant I2 to assert that after every applied patch, the
+     * accumulator has an entry for each file the patch touched, and the
+     * entry's content matches on-disk.
      */
-    getAccumulatorSnapshot(): ReadonlyMap<string, {
-        content: string;
-        baseGeneration: string;
-    }>;
+    getAccumulatorSnapshot(): ReadonlyMap<string, AccumulatorEntry>;
     /**
      * Apply all patches, returning results for each.
      * Skips patches that match exclude patterns in replay.yml
@@ -513,6 +488,59 @@ declare class ReplayCommitter {
     getTreeHash(commitSha: string): Promise<string>;
 }
 
+/**
+ * Inputs for one ownership resolution call.
+ *
+ * `originalFileName` is the pre-rename path used when the generator moved
+ * the file between generations — tree lookups at ancestor generations need
+ * the original path because that's where the generator produced the content.
+ *
+ * `warnedGens` and `warnings` are mutable accumulators threaded across calls
+ * within a single replay run. The canonical path appends a one-time warning
+ * when a base generation tree is unreachable (shallow clone / aggressive GC)
+ * so the customer sees a single message per affected base, not one per file.
+ */
+interface OwnershipContext {
+    readonly file: string;
+    readonly originalFileName?: string;
+    readonly patch: StoredPatch;
+    readonly currentGenSha: string;
+    readonly fernignorePatterns: readonly string[];
+    readonly warnedGens: Set<string>;
+    readonly warnings: string[];
+}
+/**
+ * Single canonical home for "is this file user-owned?" resolution. Every
+ * service-level check (preGenerationRebase, rebasePatches, trimAbsorbedFiles)
+ * routes through `resolveCanonical`.
+ *
+ * The earlier `rebasePatches` inline variant (`resolveAtCurrentGen`) was
+ * collapsed under FER-10386 once pre-flight investigation showed its
+ * narrower fall-back was harmless on every reachable scenario but worse
+ * on the unreachable-base-tree case. See `docs/known-divergences.md`
+ * entry 5 for the closed-out divergence record.
+ */
+declare class FileOwnership {
+    private readonly git;
+    constructor(git: GitClient);
+    /**
+     * Canonical resolution. Returns true if `file` is user-owned per:
+     *
+     *   1. `patch.user_owned === true` — authoritative, persisted flag.
+     *   2. `file === ".fernignore"` — always user-owned.
+     *   3. File matches a `.fernignore` pattern (via minimatch).
+     *   4. Patch content shows `--- /dev/null` for this file (legacy-safe
+     *      signal for patches predating `user_owned` or whose flag was lost).
+     *   5. Tree-based check against `patch.base_generation` when reachable
+     *      AND distinct from `currentGenSha`. Unreachable base → conservative
+     *      user-owned (silent-absorption safety net), with a one-time warning
+     *      per base SHA.
+     *   6. Final fallback: check `currentGenSha` when no usable base exists
+     *      (legacy one-gen lockfile).
+     */
+    resolveCanonical(ctx: OwnershipContext): Promise<boolean>;
+}
+
 interface ConflictDetail {
     patchId: string;
     patchMessage: string;
@@ -578,7 +606,7 @@ interface ApplyOptions {
  * Contract for consumers (e.g., generator-cli pipeline inserting AutoVersionStep):
  *
  * - Between `prepareReplay` and `applyPreparedReplay`, HEAD is at the new
- *   `[fern-generated]` commit (unless `_prepared.terminal === true`, e.g. dry-run).
+ *   `[fern-generated]` commit (unless `_prepared.kind === "terminal"`, e.g. dry-run).
  * - Consumers MAY land additional commits on HEAD between phases. `applyPatches`
  *   runs against current HEAD at phase-2 call time, so mid-phase commits are
  *   respected. `rebasePatches` uses `currentGenerationSha` (the pure `[fern-generated]`
@@ -595,7 +623,7 @@ interface ApplyOptions {
  *     prep.previousGenerationSha != null && prep.flow !== "skip-application"
  */
 interface ReplayPreparation {
-    flow: "first-generation" | "no-patches" | "normal-regeneration" | "skip-application";
+    flow: FlowKind;
     /** lockfile.current_generation from BEFORE this run; null iff no prior generation exists */
     previousGenerationSha: string | null;
     /** SHA of the new [fern-generated] commit created by prepareReplay (or HEAD for dry-run terminals) */
@@ -605,12 +633,26 @@ interface ReplayPreparation {
     /** @internal Opaque state consumed by applyPreparedReplay */
     readonly _prepared: InternalPreparationState;
 }
-/** @internal */
-interface InternalPreparationState {
-    flow: "first-generation" | "no-patches" | "normal-regeneration" | "skip-application";
-    /** true → applyPreparedReplay returns preparedReport without disk/git work (dry-run path) */
-    terminal: boolean;
-    preparedReport?: ReplayReport;
+/**
+ * @internal
+ * Opaque state passed from `prepareReplay` to `applyPreparedReplay`.
+ *
+ * Discriminated by `kind`:
+ * - `"terminal"` — phase 2 returns `preparedReport` without disk/git work
+ *   (dry-run, first-generation with no patch work, no-patches with no
+ *   detection results). Apply is a no-op.
+ * - `"active"` — phase 2 must apply patches, rebase, save lockfile, commit.
+ *   Carries the patch set + cached phase-1 state.
+ */
+type InternalPreparationState = InternalPreparationTerminal | InternalPreparationActive;
+interface InternalPreparationTerminal {
+    readonly kind: "terminal";
+    readonly flow: FlowKind;
+    readonly preparedReport: ReplayReport;
+}
+interface InternalPreparationActive {
+    readonly kind: "active";
+    readonly flow: FlowKind;
     /** post-preGenRebase, post-detection, post-absorption (references, not copies) */
     patchesToApply: StoredPatch[];
     /** subset of patchesToApply that were freshly detected this cycle (vs already in the lockfile) */
@@ -629,33 +671,43 @@ interface InternalPreparationState {
     optionsSnapshot?: ReplayOptions;
 }
 declare class ReplayService {
-    private git;
-    private detector;
-    private applicator;
-    private committer;
-    private lockManager;
-    private outputDir;
+    /** @internal Used by Flow implementations in `src/flows/`. */
+    git: GitClient;
+    /** @internal Used by Flow implementations in `src/flows/`. */
+    detector: ReplayDetector;
+    /** @internal Used by Flow implementations in `src/flows/`. */
+    applicator: ReplayApplicator;
+    /** @internal Used by Flow implementations in `src/flows/`. */
+    committer: ReplayCommitter;
+    /** @internal Used by Flow implementations in `src/flows/`. */
+    lockManager: LockfileManager;
+    /** @internal Used by Flow implementations in `src/flows/`. */
+    fileOwnership: FileOwnership;
+    /** @internal Used by Flow implementations in `src/flows/`. */
+    outputDir: string;
     /** @internal Test-only. Captures the last ReplayResult[] returned from applicator.applyPatches(). */
-    private _lastApplyResults;
+    _lastApplyResults: ReplayResult[];
     /**
      * Service-level warnings accumulated during a single runReplay() call.
      * Merged with `detector.warnings` into `ReplayReport.warnings` by each flow handler.
-     * Populated by `isFileUserOwned` when a patch's base generation tree is unreachable
-     * (shallow clone / aggressive `git gc --prune`) and we fall back to a conservative
-     * heuristic. Cleared at the top of `runReplay()`.
+     * Populated by `FileOwnership.resolveCanonical` when a patch's base generation tree
+     * is unreachable (shallow clone / aggressive `git gc --prune`) and we fall back to a
+     * conservative heuristic. Cleared at the top of `runReplay()`.
+     *
+     * @internal Used by Flow implementations in `src/flows/`.
      */
-    private warnings;
+    warnings: string[];
     /**
      * @internal Test-only accessor.
      * Returns the ReplayApplicator instance used for the last run. Tests use this
-     * to inspect the inter-patch accumulator after runReplay() completes (FER-9791, I2).
+     * to inspect the inter-patch accumulator after runReplay() completes (invariant I2).
      */
     get applicatorRef(): ReplayApplicator;
     /**
      * @internal Test-only accessor.
      * Returns the ReplayResult[] from the most recent applyPatches() call. Tests use
-     * this to filter applied-vs-conflicted-vs-absorbed patches for invariant assertions
-     * (FER-9791). Returns an empty array if no patches have been applied yet.
+     * this to filter applied-vs-conflicted-vs-absorbed patches for invariant
+     * assertions. Returns an empty array if no patches have been applied yet.
      */
     getLastResults(): ReadonlyArray<ReplayResult>;
     constructor(outputDir: string, _config: ReplayConfig);
@@ -682,6 +734,16 @@ declare class ReplayService {
      * its own post-commit logic), this returns the precomputed report.
      */
     applyPreparedReplay(prep: ReplayPreparation, options?: ApplyOptions): Promise<ReplayReport>;
+    /**
+     * Construct the flow for the current run. `selectFlow` is called from
+     * `prepareReplay` and decides based on options + lockfile state.
+     */
+    private selectFlow;
+    /**
+     * Construct a flow given its kind. Used by `applyPreparedReplay` to
+     * route to the same kind that was selected in phase 1.
+     */
+    private flowForKind;
     /**
      * Backwards-compatible atomic entry point. Composes `prepareReplay` + `applyPreparedReplay`.
      * Behavior is byte-identical to the pre-split implementation for all existing callers.
@@ -703,28 +765,20 @@ declare class ReplayService {
         baseBranchHead?: string;
     }): Promise<void>;
     private determineFlow;
-    private firstGenerationReport;
-    private _prepareFirstGeneration;
-    private _applyFirstGeneration;
-    /**
-     * Skip-application mode phase 1: commit the generation and update the
-     * in-memory lockfile, but don't detect or apply patches. Sets a marker
-     * so the next normal run skips revert detection in preGenerationRebase().
-     *
-     * Disk save is deferred to `_applySkipApplication`.
-     */
-    private _prepareSkipApplication;
-    private _applySkipApplication;
-    private _prepareNoPatchesRegeneration;
-    private _applyNoPatchesRegeneration;
-    private _prepareNormalRegeneration;
-    private _applyNormalRegeneration;
     /**
      * Rebase cleanly applied patches so they are relative to the current generation.
      * This prevents recurring conflicts on subsequent regenerations.
      * Returns the number of patches rebased.
+     *
+     * @internal Used by Flow implementations in `src/flows/`.
      */
-    private rebasePatches;
+    rebasePatches(results: ReplayResult[], currentGenSha: string): Promise<{
+        absorbed: number;
+        repointed: number;
+        contentRebased: number;
+        keptAsUserOwned: number;
+        absorbedPatchIds: Set<string>;
+    }>;
     /**
      * Read THEIRS snapshot (post-customer-edit content) for a list of files
      * from the working tree on disk. Used by `rebasePatches` after a clean
@@ -735,17 +789,28 @@ declare class ReplayService {
      */
     private readSnapshotFromDisk;
     /**
-     * FER-10203: returns true when a `[fern-autoversion]` commit between
-     * `fromSha` and `toSha` touched any of the patch's `files`. Re-classifies
-     * each grep match via `isGenerationCommit` so a customer commit that
-     * merely quotes the marker in its body doesn't false-positive.
+     * Detects autoversion contamination — returns true when a
+     * `[fern-autoversion]` commit between `fromSha` and `toSha` touched any
+     * of the patch's `files`. Re-classifies each grep match via
+     * `isGenerationCommit` so a customer commit that merely quotes the
+     * marker in its body doesn't false-positive.
+     *
+     * Used by preGenerationRebase to skip the customer-content rebuild for
+     * patches whose files were last touched by an autoversion step — a
+     * naive `git diff currentGen HEAD` there would capture the
+     * placeholder→semver swap as customer customization.
      */
     private hasAutoversionContamination;
     /**
-     * FER-10203: rebuild patch_content from `theirs_snapshot` (captured at
-     * detection time, predates pipeline content) rather than a HEAD-relative
-     * diff. Returns `null` when snapshot is missing or doesn't cover every
-     * file in `patch.files` — caller leaves the patch unchanged.
+     * Rebuild patch_content from `theirs_snapshot` (captured at detection
+     * time, predates pipeline content) rather than a HEAD-relative diff.
+     * Returns `null` when snapshot is missing or doesn't cover every file
+     * in `patch.files` — caller leaves the patch unchanged.
+     *
+     * Used as the autoversion-contamination escape hatch: when the
+     * HEAD-relative diff would capture pipeline content (autoversion's
+     * placeholder swap) as customer customization, the snapshot path
+     * preserves the customer's actual intent.
      */
     private computeSnapshotBasedPatchDiff;
     /**
@@ -764,7 +829,7 @@ declare class ReplayService {
      * **Skips patches sharing files with other patches.** HEAD's content
      * for a file shared by N patches is cumulative across all of them, so
      * a HEAD-fallback would falsely encode other patches' contributions
-     * into one patch's snapshot — breaking FER-9525 cross-patch isolation
+     * into one patch's snapshot — breaking cross-patch isolation
      * if the snapshot fallback later fires. Per-patch snapshots only
      * make sense when the patch owns its file. Multi-patch-same-file
      * legacy lockfiles keep using line-anchored reconstruction (the
@@ -778,37 +843,6 @@ declare class ReplayService {
      * Skips patches that already have a snapshot.
      */
     private migratePatchesToSnapshot;
-    /**
-     * Determine whether `file` is user-owned (never produced by the generator).
-     *
-     * Resolution order (first match wins):
-     *  1. `patch.user_owned === true` — authoritative, persisted across cycles.
-     *  2. `.fernignore` itself, or file matches a .fernignore pattern.
-     *  3. Legacy-safe signal: `patch_content` shows this file as a `--- /dev/null`
-     *     creation. Works for patches that predate the `user_owned` field or
-     *     whose flag was lost. Immune to rename tricks — relies on raw patch text.
-     *  4. Tree-based check against `patch.base_generation` when it is reachable
-     *     AND distinct from `currentGenSha`. If the base tree is unreachable
-     *     (shallow clone / aggressive `git gc --prune`), emit a one-time
-     *     customer-actionable warning (deduplicated via warnedGens) and
-     *     conservatively treat as user-owned — strictly safer than silent
-     *     absorption (FER-9809).
-     *  5. Final fallback — check `currentGenSha` when there is no usable base
-     *     (legacy one-gen lockfile). Preserves pre-fix behavior for that edge.
-     *
-     * `originalFileName` is the pre-rename path when the generator moved the
-     * file between the patch's base and the current generation. Tree lookups
-     * at ancestor generations use the original path — that's where the
-     * generator produced the content.
-     */
-    private isFileUserOwned;
-    /**
-     * Returns true if `file`'s diff section in `patchContent` starts with
-     * `--- /dev/null`, meaning this file was introduced by the patch (user
-     * creation). Used as a legacy-safe fallback when `patch.user_owned` is
-     * absent or cleared.
-     */
-    private fileIsCreationInPatchContent;
     /**
      * For conflict patches with mixed results (some files merged, some conflicted),
      * check if the cleanly merged files were absorbed by the generator (empty diff).
@@ -823,7 +857,12 @@ declare class ReplayService {
      * Pre-generation rebase: update patches using the customer's current state.
      * Called BEFORE commitGeneration() while HEAD has customer code.
      */
-    private preGenerationRebase;
+    /** @internal Used by Flow implementations in `src/flows/`. */
+    preGenerationRebase(patches: StoredPatch[]): Promise<{
+        conflictResolved: number;
+        conflictAbsorbed: number;
+        contentRefreshed: number;
+    }>;
     /**
      * After applyPatches(), surface a warning for each (patch × file) where
      * diff3 silently dropped lines that were unchanged context in the
@@ -832,21 +871,35 @@ declare class ReplayService {
      * relied on them. This is the "surface or preserve, never silently drop"
      * contract for legitimate-deletion cases.
      */
-    private recordDroppedContextLineWarnings;
+    /** @internal Used by Flow implementations in `src/flows/`. */
+    recordDroppedContextLineWarnings(results: ReplayResult[]): void;
     /**
      * After applyPatches(), strip conflict markers from conflicting files
      * so only clean content is committed. Keeps the Generated (OURS) side.
      */
-    private revertConflictingFiles;
+    /** @internal Used by Flow implementations in `src/flows/`. */
+    revertConflictingFiles(results: ReplayResult[]): void;
     /**
      * Clean up stale conflict markers left by a previous crashed run.
      * Called after commitGeneration() when HEAD is the [fern-generated] commit.
      * Restores files to their clean generated state from HEAD.
      * Skips .fernignore-protected files to prevent overwriting user content.
      */
-    private cleanupStaleConflictMarkers;
+    /** @internal Used by Flow implementations in `src/flows/`. */
+    cleanupStaleConflictMarkers(): Promise<void>;
     private readFernignorePatterns;
-    private buildReport;
+    /** @internal Used by Flow implementations in `src/flows/`. */
+    buildReport(flow: "first-generation" | "no-patches" | "normal-regeneration" | "skip-application", patches: StoredPatch[], results: ReplayResult[], options?: ReplayOptions, warnings?: string[], rebaseCounts?: {
+        absorbed: number;
+        repointed: number;
+        contentRebased: number;
+        keptAsUserOwned: number;
+        absorbedPatchIds: Set<string>;
+    }, preRebaseCounts?: {
+        conflictResolved: number;
+        conflictAbsorbed: number;
+        contentRefreshed: number;
+    }, patchesReverted?: number): ReplayReport;
 }
 
 interface MigrationAnalysis {
@@ -1053,4 +1106,4 @@ interface StatusGeneration {
 }
 declare function status(outputDir: string): StatusResult;
 
-export { type ApplyOptions, type BootstrapOptions, type BootstrapResult, CREDENTIAL_PATTERNS, type CommitInfo, type CommitOptions, type ConflictDetail, type ConflictMetadata, type ConflictReason, type ConflictRegion, type CredentialPattern, type CustomizationsConfig, type DetectionResult, type DiffStat, FERN_BOT_EMAIL, FERN_BOT_LOGIN, FERN_BOT_NAME, FernignoreMigrator, type FileResult, type ForgetOptions, type ForgetResult, type GenerationLock, type GenerationRecord, GitClient, LockfileManager, LockfileNotFoundError, type MatchedPatch, type MergeResult, type MigrationAnalysis, type MigrationResult, type MoveDeclaration, ReplayApplicator, ReplayCommitter, type ReplayConfig, ReplayDetector, type ReplayOptions, type ReplayPreparation, type ReplayReport, type ReplayResult, ReplayService, type ResetOptions, type ResetResult, type ResolveOptions, type ResolveResult, SENSITIVE_FILE_PATTERNS, type StatusGeneration, type StatusPatch, type StatusResult, type StoredPatch, type UnresolvedPatchInfo, bootstrap, forget, isGenerationCommit, isReplayCommit, isRevertCommit, isSensitiveFile, parseRevertedMessage, parseRevertedSha, reset, resolve, scanForCredentials, status, threeWayMerge };
+export { type ApplyOptions, type BootstrapOptions, type BootstrapResult, CREDENTIAL_PATTERNS, type CommitInfo, type CommitOptions, type ConflictDetail, type ConflictMetadata, type ConflictReason, type ConflictRegion, type CredentialPattern, type CustomizationsConfig, type DetectionResult, type DiffStat, FERN_BOT_EMAIL, FERN_BOT_LOGIN, FERN_BOT_NAME, FernignoreMigrator, type FileResult, type FlowKind, type ForgetOptions, type ForgetResult, type GenerationLock, type GenerationRecord, GitClient, LockfileManager, LockfileNotFoundError, type MatchedPatch, type MergeResult, type MigrationAnalysis, type MigrationResult, type MoveDeclaration, ReplayApplicator, ReplayCommitter, type ReplayConfig, ReplayDetector, type ReplayOptions, type ReplayPreparation, type ReplayReport, type ReplayResult, ReplayService, type ResetOptions, type ResetResult, type ResolveOptions, type ResolveResult, SENSITIVE_FILE_PATTERNS, type StatusGeneration, type StatusPatch, type StatusResult, type StoredPatch, type UnresolvedPatchInfo, bootstrap, forget, isGenerationCommit, isReplayCommit, isRevertCommit, isSensitiveFile, parseRevertedMessage, parseRevertedSha, reset, resolve, scanForCredentials, status, threeWayMerge };