@stringsync/splates 0.0.61 → 1.13.3

package/vendor/@stringsync/splates-server/merge/gate.d.ts

@@ -0,0 +1,108 @@
+import type { Fs } from "../../../core/system/index.js";
+import { Duration } from "../../../core/time/index.js";
+import type { Config } from "../config";
+import type { Git } from "../git";
+import { type PlacedAcquireOptions, type PlacedLock } from "../server/shared";
+import type { LivePhase } from "../tasks";
+import type { Shell } from "../terminal";
+import { type GateTrail } from "./cores";
+import type { MergeTiming } from "./timing";
+/** Told a whole gate's phases so far each time they change while it runs. */
+export type OnPhases = (phases: LivePhase[]) => Promise<void>;
+/** How long a merge waits for the premerge lock before its line says it is queued. */
+export declare const QUEUED_AFTER_MS = 1000;
+/** A scratch checkout of one commit, gone once disposed of. */
+export interface Checkout extends AsyncDisposable {
+    path: string;
+}
+/** A hook's output and its fresh JUnit report, kept together for attribution. */
+export interface GateRun {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    xml: string;
+    /** Whether it ran past its timeout and was killed. */
+    timedOut?: boolean;
+    /** How long it had before it would be killed; left out when nothing ran. */
+    deadlineMs?: number;
+}
+/**
+ * Runs merge checks on this machine, including isolated retests: one merge's
+ * gate at a time, holding the machine's premerge lock, each killed past
+ * `timeoutMs`, which a whole gate stretches by its load (`gateDeadline`).
+ */
+export declare class MergeGate {
+    private readonly git;
+    private readonly shell;
+    private readonly fs;
+    private readonly config;
+    private readonly timing;
+    private readonly premerge;
+    /** Sizes each run's workers, by the load less the gate before's share. */
+    private readonly trail;
+    private readonly timeoutMs;
+    private readonly phasesEveryMs;
+    constructor(git: Git, shell: Shell, fs: Fs, config: Config, timing: MergeTiming, premerge: PlacedLock, 
+    /** Sizes each run's workers, by the load less the gate before's share. */
+    trail: GateTrail, timeoutMs?: number, phasesEveryMs?: number);
+    /**
+     * Holds the machine's premerge lock for a gate run, waiting for any other
+     * premerge on the machine: call it before a merge takes a tree lock, and
+     * dispose of the result once the gate and its retests are done.
+     */
+    reserve(
+    /**
+     * Called when the lock is not had within `QUEUED_AFTER_MS`, with this
+     * merge's place in line (1 is next), and again each time the place
+     * changes, one call at a time.
+     */
+    onQueued?: (place: number) => Promise<void>, 
+    /** Aborted by a merge that stops wanting the lock, as a batch's follower does once it is landed. */
+    signal?: AbortSignal, opts?: PlacedAcquireOptions): Promise<AsyncDisposable>;
+    /** The checks to run before the merge waits for the lock, or "". */
+    get preLock(): string;
+    /**
+     * Runs the `preLock` checks in `cwd`: call it before the merge joins the
+     * line, and the whole gate skips them once they passed on this commit.
+     */
+    checkBeforeLock(cwd: string, task: string, output?: string): Promise<GateRun>;
+    /** The commit the `preLock` checks passed on, if they did. */
+    private checked;
+    /** The file a command's output goes to as it prints, when given one. */
+    private printed;
+    /** How long the whole gate may run before it is killed, on a machine whose cores it fits. */
+    get timeout(): Duration;
+    get command(): string;
+    /**
+     * Runs the gate in `cwd`, or just the test `files` of a retest, which with
+     * `at` run on that commit of the repository instead. The whole gate runs
+     * the `recent` test files that failed earlier gates before the rest, and
+     * tells `onPhases` its phases as they start and end, and what it prints to
+     * the file at `output`.
+     */
+    run(cwd: string, task: string, { files, at, recent, onPhases, output, }?: {
+        files?: string[];
+        at?: string;
+        recent?: string[];
+        onPhases?: OnPhases;
+        output?: string;
+    }): Promise<GateRun>;
+    /** Here, under the premerge lock; a retest `at` a commit in a checkout of it made for the run. */
+    private runHere;
+    /**
+     * A detached checkout of `at` named `name` beside the task worktrees, as
+     * a batch gates its stacked tip in, removed when disposed of; throws when
+     * git cannot make or remove it. Run the whole gate there with `run`,
+     * which installs its dependencies as the command's `postRewrite` does.
+     */
+    checkout(cwd: string, at: string, name: string): Promise<Checkout>;
+    private runIn;
+    /**
+     * Reads the phases file at `path` every few seconds until disposed of,
+     * telling `onPhases` whenever what it lists changed. A read or a telling
+     * that fails only leaves the page a step behind.
+     */
+    private watchPhases;
+    /** The baseline needs its own dependencies, never the task's node_modules. */
+    private prepare;
+}

package/vendor/@stringsync/splates-server/merge/github-app.d.ts

@@ -0,0 +1,99 @@
+import type { Creds } from "../creds";
+/** Where GitHub's REST API answers. */
+export declare const GITHUB_API = "https://api.github.com";
+/** The cred keeping the GitHub App's id, which its JWTs are issued as. */
+export declare const APP_ID = "SPLATES_GITHUB_APP_ID";
+/** The cred keeping the GitHub App's private key, in PEM, which signs its JWTs. */
+export declare const APP_KEY = "SPLATES_GITHUB_APP_KEY";
+/** A repository on github.com, as a remote's URL names it. */
+export interface GitHubRepo {
+    owner: string;
+    name: string;
+}
+/** A token for pushing to one repository, and when it stops working. */
+export interface InstallationToken {
+    token: string;
+    expiresAt: Date;
+}
+/** What a `GitHubApp` works through; the real ones by default. */
+export interface GitHubAppOptions {
+    fetch?: typeof fetch;
+    /** The time, in ms, its JWTs are issued at. */
+    now?: () => number;
+}
+/**
+ * The GitHub App the user installs on a repository, so workers push with a
+ * token it mints rather than a credential of the user's. Each token is good
+ * for about an hour, for this repository's contents alone, and the ruleset
+ * on trunk is what keeps it to `splates/*`: the App can never push main or
+ * change the repository's settings.
+ */
+export declare class GitHubApp {
+    private readonly id;
+    private readonly fetch;
+    private readonly now;
+    private readonly key;
+    constructor(id: string, key: string, opts?: GitHubAppOptions);
+    /** The App whose id and key `creds` keep, or null until both are saved. */
+    static kept(creds: Creds, opts?: GitHubAppOptions): Promise<GitHubApp | null>;
+    /** What GitHub knows of the App, which a wrong id or key cannot read. */
+    about(): Promise<AppAbout>;
+    /** Whether the App is installed on `repo`. */
+    installed(repo: GitHubRepo): Promise<boolean>;
+    /**
+     * Deletes the App's installation on `repo`, with the App's JWT, which
+     * takes it off every repository it was installed on with that one.
+     * Whether there was one to delete.
+     */
+    uninstall(repo: GitHubRepo): Promise<boolean>;
+    /** `repo`'s rulesets, on branches and tags, read with one of the App's tokens. */
+    rulesets(repo: GitHubRepo, token: InstallationToken): Promise<RulesetListing[]>;
+    /**
+     * The type of each rule `repo`'s rulesets apply to `branch`, as `update`,
+     * read with one of its tokens: whoever a ruleset lets bypass it, the
+     * rule is listed.
+     */
+    rules(repo: GitHubRepo, branch: string, token: InstallationToken): Promise<string[]>;
+    /**
+     * Whether an active tag ruleset of `repo` puts every rule in `types` on
+     * every tag, read with one of the App's tokens. The rules endpoint reads
+     * branches alone, so each tag ruleset is read whole.
+     */
+    tagsRestricted(repo: GitHubRepo, types: readonly string[], token: InstallationToken): Promise<boolean>;
+    /**
+     * A token that pushes to `repo`'s contents and nothing else, from the
+     * App's installation there.
+     */
+    token(repo: GitHubRepo): Promise<InstallationToken>;
+    /**
+     * The App's own JWT, which only finds its installation and mints its
+     * tokens: GitHub takes one for at most ten minutes, issued a minute back
+     * for clocks that drift.
+     */
+    jwt(): string;
+    private call;
+}
+/**
+ * The github.com repository a remote URL names, in any of the shapes git
+ * takes one in; null for a remote anywhere else.
+ */
+export declare function githubRepo(url: string): GitHubRepo | null;
+/** The App as GitHub knows it: what it is called and what it may do. */
+export interface AppAbout {
+    /** Its name in URLs, as in `https://github.com/apps/<slug>`. */
+    slug: string;
+    /** Each permission it was given, as `contents: "write"`. */
+    permissions: Record<string, string>;
+    /** The account that owns it, whose settings keep it; none when GitHub leaves it out. */
+    owner?: {
+        login: string;
+        type: string;
+    } | null;
+}
+/** A ruleset as `rulesets` lists it. */
+export interface RulesetListing {
+    id: number;
+    name?: string;
+    target: string;
+    enforcement: string;
+}

package/vendor/@stringsync/splates-server/merge/github-refused.d.ts

@@ -0,0 +1,5 @@
+/** GitHub refusing a call, with the status it refused with. */
+export declare class GitHubRefused extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}

package/vendor/@stringsync/splates-server/merge/groups.d.ts

@@ -0,0 +1,8 @@
+import type { Storage } from "../storage";
+/** Confirmed companions of a merge gate, read without changing its coordination records. */
+export declare class BatchGroups {
+    private readonly storage;
+    constructor(storage: Storage);
+    /** Running tasks sharing a stack, leader first; invitations and settled batches are left out. */
+    active(running: string[]): Promise<string[][]>;
+}

package/vendor/@stringsync/splates-server/merge/index.d.ts

@@ -0,0 +1,19 @@
+export type { AttributedFailure, FailureAttribution } from "./attribution";
+export { attributeFailure } from "./attribution";
+export type { BatchResult, Member } from "./batch";
+export { MERGE_BATCH_CAP, MergeBatch } from "./batch";
+export type { AppSource, Pushed, TokenMinter } from "./branches";
+export { PUSHED_PREFIX, pushedLine, TaskBranches, } from "./branches";
+export type { MergeEstimates } from "./estimates";
+export { ESTIMATED_FROM, mergeEstimates } from "./estimates";
+export type { GateRun } from "./gate";
+export { MergeGate } from "./gate";
+export type { GitHubRepo, InstallationToken } from "./github-app";
+export { APP_ID, APP_KEY, GitHubApp, githubRepo } from "./github-app";
+export { BatchGroups } from "./groups";
+export { landTested } from "./landing";
+export { landLocally } from "./local-landing";
+export { merge } from "./merge";
+export type { TimedTest } from "./test-report";
+export type { Landed, TrunkLanding } from "./trunk";
+export { CoordinatorLanding } from "./trunk";

package/vendor/@stringsync/splates-server/merge/index.js

@@ -0,0 +1,46 @@
+import {
+  attributeFailure2,
+  MERGE_BATCH_CAP2,
+  MergeBatch2,
+  APP_ID2,
+  APP_KEY2,
+  GitHubApp2,
+  githubRepo2,
+  PUSHED_PREFIX2,
+  TaskBranches2,
+  pushedLine2,
+  ESTIMATED_FROM2,
+  mergeEstimates2,
+  MergeGate2,
+  BatchGroups2,
+  landLocally2,
+  landTested2,
+  merge2,
+  CoordinatorLanding2
+} from "../index-caep3sde.js";
+import"../index-01z7ycdk.js";
+import"../index-e9z7s5hh.js";
+import"../index-kmzdvvt0.js";
+import"../index-t9w5a8ed.js";
+import"../index-0jttnv86.js";
+import"../index-g18nxyn7.js";
+export {
+  APP_ID2 as APP_ID,
+  APP_KEY2 as APP_KEY,
+  BatchGroups2 as BatchGroups,
+  CoordinatorLanding2 as CoordinatorLanding,
+  ESTIMATED_FROM2 as ESTIMATED_FROM,
+  GitHubApp2 as GitHubApp,
+  MERGE_BATCH_CAP2 as MERGE_BATCH_CAP,
+  MergeBatch2 as MergeBatch,
+  MergeGate2 as MergeGate,
+  PUSHED_PREFIX2 as PUSHED_PREFIX,
+  TaskBranches2 as TaskBranches,
+  attributeFailure2 as attributeFailure,
+  githubRepo2 as githubRepo,
+  landLocally2 as landLocally,
+  landTested2 as landTested,
+  merge2 as merge,
+  mergeEstimates2 as mergeEstimates,
+  pushedLine2 as pushedLine
+};

package/vendor/@stringsync/splates-server/merge/landed.d.ts

@@ -0,0 +1,28 @@
+import type { Git } from "../git";
+import type { LandedSince } from "../records";
+import type { FinishedTask } from "../tasks";
+import type { FailingCase } from "./test-report";
+/**
+ * What landed on the base between the task's last base and the one it was
+ * just tested on: the commits touching the failing test files, what they
+ * import, or what the task changed. When none does, the whole range if it is
+ * short, so a semantic conflict with something that just landed reads as one.
+ * Null when the base had not moved.
+ */
+export declare function landedSince({ git, finished, }: {
+    git: Git;
+    finished: {
+        list(): Promise<FinishedTask[]>;
+    };
+}, { cwd, from, to, head, failing, }: {
+    cwd: string;
+    /** The base the branch sat on before the merge rebased it, null when unknown. */
+    from: string | null;
+    /** The base it was rebased onto and tested against. */
+    to: string;
+    /** The tested commit, the task on `to`. */
+    head: string;
+    failing: FailingCase[];
+}): Promise<LandedSince | null>;
+/** The block a `tests_failed` message shows of `landed`, or no lines when nothing landed. */
+export declare function landedLines(base: string, landed: LandedSince | null): string[];

package/vendor/@stringsync/splates-server/merge/landing.d.ts

@@ -0,0 +1,38 @@
+import type { Lock } from "../../../core/system/index.js";
+import type { Git } from "../git";
+import type { Facts } from "../records";
+import type { Worktree, WorktreeService } from "../tasks";
+import type { TaskBranches } from "./branches";
+import type { TrunkLanding } from "./trunk";
+/**
+ * Lands the exact tip certified by a gate, or returns null when its base
+ * moved and it needs another rebase and gate. No heavy work holds this lock.
+ * Callers hold the task's merge-tree lock until they finish with its checkout.
+ * A batch's leader lands the stack's `tip`, which its own `testedHead` is
+ * under, as one move of the base.
+ */
+export declare function landTested({ service, git, lock, branches, trunk, }: {
+    service: WorktreeService;
+    git: Git;
+    lock: Lock;
+    branches: TaskBranches;
+    trunk: TrunkLanding;
+}, worktree: Worktree, { remote, onto, testedHead, tip, }: {
+    remote: string | null;
+    onto: string;
+    testedHead: string;
+    tip?: string;
+}, facts: Partial<Facts["merge"]>): Promise<{
+    current: Worktree;
+    head: string;
+    landing: string;
+    landed: {
+        status: "landed";
+        local: "moved" | {
+            stuck: string;
+        };
+    } | null;
+    changed: string[];
+    commits: string[] | undefined;
+    size: import("../tasks").DiffSize | undefined;
+} | null>;

package/vendor/@stringsync/splates-server/merge/local-landing.d.ts

@@ -0,0 +1,11 @@
+import type { Git, GitResult } from "../git";
+/** Lands one tested tip, refusing to overwrite a base that moved meanwhile. */
+export declare function landLocally({ git, base, onto, head, landing, }: {
+    git: Git;
+    base: string;
+    onto: string;
+    head: string;
+    landing: string | null;
+}): Promise<GitResult & {
+    moved?: boolean;
+}>;

package/vendor/@stringsync/splates-server/merge/merge-state.d.ts

@@ -0,0 +1,37 @@
+import type { PlacedAcquireOptions } from "../server/shared";
+import type { FailedTest, GateFailure, MergeFailure, Worktree } from "../tasks";
+/** Guards merge mutations and records refusals on the task that owns them. */
+export declare class MergeState {
+    private readonly worktree;
+    constructor(worktree: Worktree);
+    /**
+     * Where it waits for the premerge lock: ahead of the line once its last
+     * merge stopped on a conflict, so only the gate already running and the
+     * merge next for it can land before it and conflict again.
+     */
+    line(): PlacedAcquireOptions;
+    /** Git owns its lock: neither its age nor an absent open fd proves it stale. */
+    refuseIndexLock(output: string, conflicts?: string[]): Promise<void>;
+    bump(reason: MergeFailure, named: Omit<GateFailure, "reason" | "at">): Promise<void>;
+    /**
+     * Records a failure that spends no attempt, so the next one can tell
+     * whether it repeats this.
+     */
+    note(reason: MergeFailure, named: Omit<GateFailure, "reason" | "at">): Promise<void>;
+    /**
+     * Records a `tests_failed` with the base it ran on. It spends an attempt
+     * only when the task failed and repeats its last such failure.
+     */
+    recordTestsFailed(taskFailed: boolean, rebasedOnto: string, failed: FailedTest[]): Promise<{
+        charged: boolean;
+        repeat: "base" | "tests" | null;
+        first: boolean;
+    }>;
+    /**
+     * The end of what git or the gate printed, bounded for the merge event,
+     * which the page opens to say why a merge was refused.
+     */
+    static said(output: string): string;
+    /** Refuses to mutate or land a tree whose lease changed while checks ran. */
+    requireLease(): Promise<Worktree>;
+}

package/vendor/@stringsync/splates-server/merge/merge.d.ts

@@ -0,0 +1,45 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Lock } from "../../../core/system/index.js";
+import { type Clock } from "../../../core/time/index.js";
+import type { Tasks } from "../board";
+import type { Config } from "../config";
+import type { Git } from "../git";
+import type { Slots } from "../ports";
+import type { Facts, Journal } from "../records";
+import type { PlacedLock } from "../server/shared";
+import type { WorktreeService } from "../tasks";
+import type { Shell } from "../terminal";
+import { MergeBatch } from "./batch";
+import type { TaskBranches } from "./branches";
+import type { TrunkLanding } from "./trunk";
+/**
+ * Lands the current worktree's branch on its base branch, trunk unless the
+ * task was created with `--base`, once the gate passes on it. Merges
+ * waiting for the gate at once land as one batch.
+ */
+export declare function merge({ service, git, lock, shell, config, log, tasks, journal, fs, slots, premerge, gateTimeoutMs, phasesEveryMs, branches, trunk, batch, clock, }: {
+    service: WorktreeService;
+    git: Git;
+    lock: Lock;
+    shell: Shell;
+    config: Config;
+    log: Logger;
+    tasks: Tasks;
+    journal?: Journal;
+    fs: Fs;
+    slots: Slots;
+    /** The machine's premerge lock, so one gate runs at a time. */
+    premerge: PlacedLock;
+    /** How long the gate may run before it is killed; `PREMERGE_TIMEOUT_MS` for none. */
+    gateTimeoutMs?: number;
+    /** How often the gate's premerge phases are read onto the record; `PHASES_EVERY_MS` by default. */
+    phasesEveryMs?: number;
+    branches: TaskBranches;
+    trunk: TrunkLanding;
+    /** Where this merge forms or joins a batch with the others waiting. */
+    batch?: MergeBatch;
+    clock?: Clock;
+}, cwd: string, facts?: Partial<Facts["merge"]>, { message, }?: {
+    /** When given, the task's commits are squashed into one with this message first. */
+    message?: string;
+}): Promise<void>;

package/vendor/@stringsync/splates-server/merge/output.d.ts

@@ -0,0 +1,19 @@
+import type { Fs, OutputWatcher } from "../../../core/system/index.js";
+/**
+ * A merge step's command output, appended to the file at `path` as it
+ * prints, for the page to follow while the step runs. Starts the file
+ * afresh; a write that fails only leaves the page short of output, never the
+ * merge.
+ */
+export declare class OutputFile implements AsyncDisposable {
+    private readonly fs;
+    private readonly path;
+    private writing;
+    constructor(fs: Fs, path: string);
+    /** What the command's spawn hands each chunk to, in the order it came. */
+    readonly watcher: OutputWatcher;
+    private append;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+/** Where `step`, the merge's `index`th, keeps its output, in the task's git directory. */
+export declare function outputPath(gitDir: string, index: number, step: string): string;

package/vendor/@stringsync/splates-server/merge/phases.d.ts

@@ -0,0 +1,27 @@
+import type { GatePhases } from "../records";
+import type { LivePhase } from "../tasks";
+/** The phases a gate's command timed, from the lines it appended to `SPLATES_GATE_PHASES`. */
+export declare class TimedPhases {
+    private readonly lines;
+    constructor(lines: string);
+    /**
+     * Sums each phase by name, then adds `setup`, what of the `ranMs` run
+     * they leave. A phase `within` another, which ran beside its siblings
+     * there, is kept but leaves the time to its parent. A line that is not a
+     * phase is passed over, as a command cut short may leave half of one.
+     */
+    of(ranMs: number): GatePhases["ms"];
+    /** The highest peak memory each phase's tests reported, in megabytes. */
+    peaks(): NonNullable<GatePhases["peakMb"]>;
+    /** The phase each phase ran inside of, for those that ran inside one. */
+    within(): NonNullable<GatePhases["within"]>;
+    /**
+     * The phases so far of a gate still running, in the order they started:
+     * each from the line that says it started, given its time once a line
+     * says it ended. A phase whose command marks only its end shows once it
+     * has.
+     */
+    live(): LivePhase[];
+    /** The lines that name a phase and give `field` as a number. */
+    private parsed;
+}

package/vendor/@stringsync/splates-server/merge/pre-lock.d.ts

@@ -0,0 +1,28 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Git } from "../git";
+import type { Facts } from "../records";
+import type { WorktreeService } from "../tasks";
+import type { MergeGate } from "./gate";
+import type { MergeState } from "./merge-state";
+/**
+ * Refuses a merge whose pre-lock checks fail, before it waits for the lock.
+ * The refusal reads as a failed gate, blamed on the environment since no
+ * test ran.
+ */
+export declare function refuseFailedChecks({ git, service, state, log, runner, }: {
+    git: Git;
+    service: WorktreeService;
+    state: MergeState;
+    log: Logger;
+    runner: MergeGate;
+}, { task, branch, base, cwd, onto, testedHead, lastBase, output, }: {
+    task: string;
+    branch: string;
+    base: string;
+    cwd: string;
+    onto: string;
+    testedHead: string;
+    lastBase: string | null;
+    /** The file the checks print to as they run. */
+    output?: string;
+}, facts: Partial<Facts["merge"]>): Promise<void>;

package/vendor/@stringsync/splates-server/merge/preflight.d.ts

@@ -0,0 +1,16 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs } from "../../../core/system/index.js";
+import type { Config } from "../config";
+import type { Git } from "../git";
+import type { Worktree } from "../tasks";
+/**
+ * Refuses a merge before it spends anything: a dirty tree, a branch
+ * tracking the plan, an exhausted budget, a lease held elsewhere, or
+ * unchecked questions and steps.
+ */
+export declare function refuseUnready({ git, fs, config }: {
+    git: Git;
+    fs: Fs;
+    config: Config;
+    log: Logger;
+}, worktree: Worktree): Promise<void>;

package/vendor/@stringsync/splates-server/merge/queue-failures.d.ts

@@ -0,0 +1,11 @@
+import type { Logger } from "../../../core/log/index.js";
+import { type Tasks } from "../board";
+import type { Journal } from "../records";
+import type { FailedTest } from "../tasks";
+import type { FailureAttribution } from "./attribution";
+/** Keep a failing test actionable even when the merge is held without an attempt. */
+export declare function queueFailedTests({ tasks, log, journal }: {
+    tasks: Tasks;
+    log: Logger;
+    journal?: Journal;
+}, task: string, failed: FailedTest[], kind: FailureAttribution): Promise<void>;

package/vendor/@stringsync/splates-server/merge/rebase.d.ts

@@ -0,0 +1,34 @@
+import type { Git } from "../git";
+import type { Facts } from "../records";
+import type { TaskBranches } from "./branches";
+import { MergeState } from "./merge-state";
+/**
+ * Rebases a task onto its base's tip, as a merge does before waiting for
+ * the gate and again after, so a conflict with what landed meanwhile stops
+ * the merge before the wait, and the gate tests what lands. Either way a
+ * conflict is one refusal, charged to the conflict budget rather than the
+ * merge attempts, since it is the base moving more than the task failing.
+ */
+export declare class BaseRebase {
+    private readonly deps;
+    private readonly of;
+    private readonly facts;
+    /**
+     * The base the branch sat on before this merge first rebased it, so a
+     * failure can name what landed since; null when git could not say.
+     */
+    lastBase: string | null | undefined;
+    constructor(deps: {
+        git: Git;
+        branches: TaskBranches;
+        state: MergeState;
+    }, of: {
+        task: string;
+        base: string;
+        /** The central remote trunk is landed on, or null for a local base. */
+        remote: string | null;
+        path: string;
+    }, facts: Partial<Facts["merge"]>);
+    /** Rebases onto the base's tip and returns that commit; refuses a conflict. */
+    onto(): Promise<string>;
+}

package/vendor/@stringsync/splates-server/merge/recent-failures.d.ts

@@ -0,0 +1,10 @@
+import type { Event, Journal } from "../records";
+/** How far back a failed gate still says which files to run first. */
+export declare const RECENT_FAILURE_MS: number;
+/**
+ * The test files that failed a merge's gate within `RECENT_FAILURE_MS` of
+ * `now`, most recent first, once each. A file fails gate after gate until a
+ * fix lands, so the next gate runs these before the rest of the suite.
+ */
+export declare function recentFailedFiles(journal: Journal | undefined, now?: number): Promise<string[]>;
+export declare function recentFailedFilesOf(entries: Event[], now: number): string[];