canopycms 0.0.67-int.90 → 0.0.67

package/dist/worker/rebase.d.ts

@@ -1,16 +1,12 @@
 import { type BranchMetadataFile } from '../branch-metadata.js';
-import { type ContentId } from '../paths/types.js';
 import type { WorkerContext } from './worker-context.js';
 /**
- * The rebase loop: the largest and most safety-critical of the four call trees
- * that used to share cms-worker.ts, and the deepest leaf of the git-sync
- * cluster. `syncGit` (git-sync.ts) calls `runRebaseCycle` once per cycle.
- *
- * Every branch workspace that is behind the base branch is rebased onto it,
- * keeping the BRANCH's version of any conflicting file. Three things make this
- * the part of the worker most likely to misbehave under real EFS and spot
- * conditions, and all three are documented at the point they happen rather
- * than here:
+ * The rebase loop: the deepest leaf of the git-sync cluster, and the most
+ * safety-critical part of the worker. `syncGit` (git-sync.ts) calls
+ * `runRebaseCycle` once per cycle; every branch workspace behind the base
+ * branch is rebased onto it, keeping the BRANCH's version of any conflicting
+ * file. Three things make it the part most likely to misbehave under real EFS
+ * and spot conditions, all documented at the point they happen:
  *
  * - it holds the [SYNC-C1] cross-host content-write lock for the whole rebase,
  *   so an editor's save cannot be destroyed mid-replay;
@@ -26,16 +22,15 @@ import type { WorkerContext } from './worker-context.js';
  */
 export type RebaseContext = Pick<WorkerContext, 'githubOwner' | 'githubRepo' | 'baseBranch' | 'sanitizedBaseBranch' | 'contentBranchesPath' | 'contentRoot' | 'remoteGitPath' | 'taskDir' | 'taskTimeoutMs' | 'octokit' | 'afterConflictDetectedForTesting' | 'afterRebaseCompletedForTesting'>;
 /**
- * Per-cycle outcome of `rebaseActiveBranches()` (PR-W1). Folded by `syncGit()`
- * into the worker's self-reported status (`WorkerStatusReport.lastGitSync`,
- * see worker-status.ts) alongside a `durationMs` measured around the whole
- * sync cycle.
+ * Per-cycle outcome of `rebaseActiveBranches()`, folded by `syncGit()` into the
+ * worker's self-reported status (`WorkerStatusReport.lastGitSync`, see
+ * worker-status.ts) alongside a `durationMs` for the whole sync cycle.
  */
 export interface RebaseSummary {
     /**
-     * Branches that were behind and completed a rebase onto the base branch
-     * (successfully, whether or not conflicts were resolved via --theirs).
-     * Branches that were already up to date are NOT listed here.
+     * Branches that were behind and completed a rebase onto the base branch,
+     * whether or not conflicts were resolved via --theirs. Branches already up to
+     * date are NOT listed here.
      */
     rebased: string[];
     /** Branches skipped this cycle because their working tree had uncommitted changes. */
@@ -60,102 +55,17 @@ export interface RebaseSummary {
     }[];
 }
 /**
- * Poll GitHub for a submitted/approved branch's PR resolution.
+ * Poll GitHub for a submitted/approved branch's PR resolution. Those branches
+ * sit outside the rebase loop and get no other signal that their PR resolved --
+ * nothing pushes a merge/close webhook back into the branch workspace.
  *
- * submitted/approved branches sit outside the rebase loop and get no
- * other signal that their PR resolved on GitHub -- nothing pushes a
- * merge/close webhook back into the branch workspace. merged ->
- * auto-archive via buildMergedBranchUpdate (shared with the manual
- * markAsMerged API so both paths produce identical archived-branch
- * metadata). closed-without-merge -> record pullRequestState only; an
- * admin decides the workflow transition from there. Best-effort: any
- * failure here is logged and swallowed, retried next sync cycle.
+ * merged -> auto-archive via buildMergedBranchUpdate, shared with the manual
+ * markAsMerged API so both paths produce identical archived-branch metadata.
+ * closed-without-merge -> record pullRequestState only; an admin decides the
+ * workflow transition. Best-effort: a failure is logged, swallowed and retried
+ * next sync cycle.
  */
 export declare function pollMergeState(ctx: RebaseContext, branchDir: string, branchPath: string, metaFile: BranchMetadataFile | null): Promise<void>;
-/**
- * Persist a per-branch rebase failure to branch.json (PR-W2), bounded to
- * roughly one save per failing branch per hour: a branch stuck failing
- * every cycle must not turn into unbounded save-per-cycle x N-failing-
- * branches write amplification -- save() eager-regenerates the branch
- * registry (branch-metadata.ts's invalidateRegistry(), O(branch count) EFS
- * reads), the same concern the `alreadyClean` no-op guard above exists
- * for.
- *
- * Best-effort and non-fatal like every other metadata write in this
- * loop's error paths: a corrupt branch.json, a lock-contention error, or
- * any other save failure here must never abort the per-branch iteration.
- * This matters doubly at the two call sites -- one is inside the outer
- * per-branch catch, with no further catch of its own around this call --
- * so the whole method is wrapped, not just the load.
- */
-export declare function recordRebaseFailure(ctx: RebaseContext, branchPath: string, branchDir: string, message: string): Promise<void>;
-/**
- * Map the file paths a rebase resolved --theirs onto the ContentIds the editor
- * shows as conflicted, deduplicated.
- *
- * IDs rather than paths because they are immutable: a later slug rename must
- * not orphan a conflict marker. Paths that carry no recoverable ID are dropped
- * rather than guessed at.
- *
- * Pure -- the one piece of this loop that can be tested without a git repo.
- */
-export declare function conflictFilesToContentIds(conflictedFiles: readonly string[], contentRoot: string): ContentId[];
-/**
- * What one branch contributed to the cycle summary -- the return type that
- * replaced `continue` when the per-branch body moved into
- * {@link rebaseOneBranch}.
- *
- * The original loop expressed this by pushing to one of four arrays in scope
- * and then `continue`-ing; there were nine such exits and each pushed to a
- * different array (or to none), which is exactly the sort of thing that is
- * easy to get wrong when the body is 640 lines long. Making it a return value
- * means the compiler checks that every path produces one.
- */
-export type BranchRebaseOutcome = 
-/** Nothing to do: a skipped status, or already up to date. Not reported. */
-{
-    kind: 'none';
-}
-/** Was behind and completed a rebase, with or without conflict resolution. */
- | {
-    kind: 'rebased';
-}
-/** Working tree had uncommitted changes. Retried next cycle. */
- | {
-    kind: 'skippedDirty';
-}
-/** [SYNC-C1] Content-write lock busy or lost mid-rebase. Retried next cycle. */
- | {
-    kind: 'skippedLocked';
-} | {
-    kind: 'failed';
-    error: string;
-    /**
-     * True when the rebase itself COMPLETED and the branch was already
-     * counted as rebased before the failure. Only reachable from the
-     * [SYNC-H1] carry-forward block, which is the sole code that runs after
-     * that point and can still throw (via markHistoryRewritten's metadata
-     * save).
-     *
-     * Not a tidying-up detail: the original loop pushed to `rebased` and
-     * THEN to `failed` in that interleaving, so the branch appeared in both
-     * buckets -- and it genuinely is both, because its history moved and
-     * publishing the move failed. Collapsing it to `failed` alone would drop
-     * a real rebase from worker-status.json.
-     *
-     * KNOWN COVERAGE GAP, stated rather than hidden: only the `false`
-     * direction is exercised (the fetch-error path in cms-worker.test.ts).
-     * Reaching the `true` direction needs `markHistoryRewritten`'s metadata
-     * save to fail AFTER a completed rebase, and there is no seam for that --
-     * the save sits between two other saves with no hook between them.
-     * Adding a production hook purely to reach it would cost more than the
-     * gap. The placement was instead verified by hand against the pre-split
-     * method: `didRebase = true` sits exactly where `rebased.push` sat, after
-     * the conflictStatus save and before the carry-forward, so a failing
-     * conflictStatus save still yields `failed` alone.
-     */
-    rebased?: boolean;
-};
 /**
  * Rebase every branch workspace that is behind the base branch, one cycle.
  *