@stringsync/splates 0.0.60 → 1.13.3

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

@@ -0,0 +1,60 @@
+// exit.ts
+var EXIT2 = {
+  usage: 1,
+  conflict: 2,
+  tests_failed: 3,
+  lease_lost: 4,
+  budget_exhausted: 5,
+  lease_held: 6,
+  dirty: 7,
+  not_found: 8,
+  hook_failed: 9,
+  exists: 10,
+  orphaned: 11,
+  merge_failed: 12,
+  already_removed: 13,
+  timeout: 14,
+  blocked: 16,
+  cycle: 18,
+  outdated: 19,
+  uninitialized: 20,
+  too_large: 21,
+  dismissed: 22,
+  no_secret_store: 23,
+  cloudflare: 24,
+  requested: 25,
+  slots_full: 26,
+  slot_running: 27,
+  not_granted: 28,
+  migration_failed: 30,
+  no_runner: 31
+};
+
+class Exit2 extends Error {
+  reason;
+  data;
+  constructor(reason, message, data = {}) {
+    super(message);
+    this.reason = reason;
+    this.data = data;
+  }
+}
+function fail2(reason, message, data = {}) {
+  throw new Exit2(reason, message, data);
+}
+function exits2() {
+  return async (ctx, next) => {
+    try {
+      await next(ctx);
+    } catch (e) {
+      if (!(e instanceof Exit2)) {
+        throw e;
+      }
+      ctx.log.info(JSON.stringify({ reason: e.reason, ...e.data }));
+      ctx.log.error(e.message);
+      ctx.ps.exit(EXIT2[e.reason]);
+    }
+  };
+}
+
+export { EXIT2, Exit2, fail2, exits2 };

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

@@ -0,0 +1,8 @@
+/**
+ * `each` of `items`, in their order, with at most `concurrency` under way at
+ * once: `Promise.all` for work that starts processes, which a long list would
+ * otherwise start all together.
+ */
+export declare function limited<T, R>(items: readonly T[], concurrency: number, each: (item: T) => Promise<R>): Promise<R[]>;
+/** How many tasks to read at once, each read running several git processes. */
+export declare const READ_CONCURRENCY = 8;

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

@@ -0,0 +1,14 @@
+import { type Logger } from "../../core/log/index.js";
+import type { Journal } from "./records";
+/** Enough to cover a session's worth of work without scrolling. */
+export declare const DEFAULT_COUNT = 20;
+export interface LogOptions {
+    /** How many of the most recent entries to show. */
+    count?: number;
+    /** Print the entries as JSON instead of a table. */
+    json?: boolean;
+}
+export declare function log({ journal, log }: {
+    journal: Journal;
+    log: Logger;
+}, { count, json }?: LogOptions): Promise<void>;

package/vendor/@stringsync/splates-server/log.js

@@ -0,0 +1,32 @@
+import {
+  table,
+  age
+} from "./index-kmzdvvt0.js";
+
+// log.ts
+import { color } from "../../core/log/index.js";
+var DEFAULT_COUNT = 20;
+async function log({ journal, log }, { count = DEFAULT_COUNT, json = false } = {}) {
+  const entries = await journal.tail(count);
+  if (json) {
+    log.info(JSON.stringify(entries, null, "\t"));
+    return;
+  }
+  if (entries.length === 0) {
+    log.info("nothing recorded yet");
+    return;
+  }
+  log.info(table(["WHEN", "ACTION", "TASK", "RESULT"], entries.map(row)));
+}
+function row(entry) {
+  return [
+    age(entry.at),
+    entry.action,
+    entry.task ?? "-",
+    entry.reason === null ? color.green("ok") + (entry.action === "merge" && (entry.batch?.length ?? 0) > 1 ? ` · gated with ${entry.batch?.filter((task) => task !== entry.task).join(", ")}` : "") : color.red(entry.reason)
+  ];
+}
+export {
+  DEFAULT_COUNT,
+  log
+};

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

@@ -0,0 +1,24 @@
+import type { FailedTest } from "../tasks";
+import type { GateRun, MergeGate } from "./gate";
+/**
+ * Why a failing gate stopped, independent of whether its task eventually lands.
+ * `inconclusive` is a gate no retest could judge (no usable report, or a retest
+ * that did not finish): it shows nothing about the environment.
+ */
+export type FailureAttribution = "task" | "trunk" | "flake" | "environment" | "inconclusive";
+export interface AttributedFailure {
+    kind: FailureAttribution;
+    failed: FailedTest[];
+    why: string;
+}
+/**
+ * Attributes one gate failure without moving the task's checkout. A future
+ * merge queue can call this against a batch's tip and its exact base commit.
+ */
+export declare function attributeFailure({ gate }: {
+    gate: MergeGate;
+}, run: GateRun, { cwd, task, onto }: {
+    cwd: string;
+    task: string;
+    onto: string;
+}): Promise<AttributedFailure>;

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

@@ -0,0 +1,119 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Ps } from "../../../core/system/index.js";
+import type { Storage } from "../storage";
+import type { FailedTest } from "../tasks";
+import type { FailureAttribution } from "./attribution";
+/** How many merges one batch gates at most, its leader included. */
+export declare const MERGE_BATCH_CAP = 4;
+/** How long a leader waits for a follower it invited to stack its branch. */
+export declare const STACK_REPLY_MS = 30000;
+/**
+ * Lets merges waiting for the premerge lock land on one gate run. The merge
+ * that takes the lock leads; the others follow and read their result here.
+ */
+export declare class MergeBatch {
+    private readonly storage;
+    private readonly ps;
+    private readonly log;
+    private readonly pollMs;
+    private readonly replyMs;
+    private readonly cap;
+    /** Followers this leader asked that did not stack, not asked again. */
+    private readonly declined;
+    constructor(storage: Storage, ps: Ps, log: Logger, opts?: MergeBatchOptions);
+    private get records();
+    /** Offers `task`'s merge onto `base` to whichever merge leads next. */
+    offer(task: string, base: string): Promise<void>;
+    /** Takes `task` out of any batch, leaving no record of it. */
+    clear(task: string): Promise<void>;
+    /** The invitation `task` has yet to answer, if any. */
+    invited(task: string): Promise<Invite | null>;
+    /** Answers an invitation: the branch's head on `onto`, or null for a conflict. */
+    stacked(task: string, onto: string, head: string | null): Promise<void>;
+    /** What the batch came to for `task`, once its leader has said. */
+    result(task: string): Promise<BatchResult | null>;
+    /**
+     * Forms `leader`'s batch: invites the merges waiting to land on `base`,
+     * oldest first and up to the cap, each onto the tip the one before it
+     * made, and returns those that stacked. A follower that declines, or
+     * does not answer in time, is left out of this leader's batches.
+     */
+    form(leader: string, base: string, tip: string): Promise<Member[]>;
+    /** Leaves `task` out of this leader's later batches, as a culprit is. */
+    exclude(task: string): void;
+    /** Drops `task`'s answer and result, as a follower a batch let go does. */
+    unstack(task: string): Promise<void>;
+    /** Tells `member` what its batch came to. */
+    tell(member: Member, result: BatchResult): Promise<void>;
+    /** Sends every member of `members` on its way alone, back on its own head. */
+    dissolve(members: Member[]): Promise<void>;
+    /**
+     * The live offers for `base`, oldest first, the leader's own and those it
+     * has given up on left out; an offer whose process is gone is dropped.
+     */
+    private waiting;
+    /** The head `task` stacked on `onto`, or null once it declined or ran out of time. */
+    private awaitStacked;
+    private read;
+    private write;
+}
+export interface MergeBatchOptions {
+    /** How often a follower looks for an invitation or result. */
+    pollMs?: number;
+    /** How long a leader waits for an invited follower to stack. */
+    replyMs?: number;
+    /** How many merges a batch gates at most, the leader included. */
+    cap?: number;
+}
+/** A merge waiting for the premerge lock that a leader may take into its batch. */
+export interface Offer {
+    task: string;
+    pid: number;
+    hostname: string;
+    /** The branch it lands on; a batch holds one base's merges only. */
+    base: string;
+    /** When it began waiting, which orders the batch first come, first served. */
+    since: string;
+}
+/** A leader's ask of a follower: put your branch on `onto`. */
+export interface Invite {
+    leader: string;
+    /** The stack's tip to rebase onto. */
+    onto: string;
+}
+/** A follower stacked on a leader's `onto`, or declined it. */
+export interface Stacked {
+    onto: string;
+    /** The branch's tip once on `onto`; null for a rebase that conflicted. */
+    head: string | null;
+}
+/** A follower's head, stacked on the batch's tip before it. */
+export interface Member {
+    task: string;
+    onto: string;
+    head: string;
+}
+/** What a batch came to for one of its followers. */
+export type BatchResult = {
+    kind: "landed";
+    head: string;
+    batch: string[];
+} | {
+    kind: "failed";
+    attribution: FailureAttribution;
+    failedTests: FailedTest[];
+    /** What the batch gate printed. */
+    output: string;
+    exitCode: number;
+    /** The commit the follower's branch was stacked on when it was gated. */
+    rebasedOnto: string;
+    /** The stack's commit holding the follower's commits, to reproduce on. */
+    at: string;
+    batch: string[];
+} | {
+    kind: "dissolved";
+};
+/** A batch's result that ends the follower's merge: landed, or refused. */
+export type Settled = Exclude<BatchResult, {
+    kind: "dissolved";
+}>;

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

@@ -0,0 +1,21 @@
+import type { Git } from "../git";
+import type { FailedTest } from "../tasks";
+import type { Member } from "./batch";
+import type { MergeGate } from "./gate";
+/**
+ * Which member of a batch the failing `failed` tests first fail with: the
+ * stack is walked from the bottom, the failing files run on each member's
+ * head in turn, and the first head they fail on names it; the tip's member
+ * when none below does, since the whole gate failed there. Null when a run
+ * fails without naming a test, which tells nothing.
+ */
+export declare function blame({ gate, git }: {
+    gate: MergeGate;
+    git: Git;
+}, { cwd, task }: {
+    cwd: string;
+    task: string;
+}, stack: Member[], failed: FailedTest[]): Promise<{
+    member: Member;
+    failed: FailedTest[];
+} | null>;

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

@@ -0,0 +1,151 @@
+import type { Config } from "../config";
+import type { Creds } from "../creds";
+import type { Git } from "../git";
+import { type PlanStore } from "../plans";
+import type { Worktree } from "../tasks";
+import { GitHubApp, type InstallationToken } from "./github-app";
+/** What a task's branch is pushed as on the central remote: `splates/<task>`. */
+export declare const PUSHED_PREFIX = "splates/";
+/** How a push or a delete of a task's branch went. */
+export type Pushed = 
+/** The remote has the branch as it stands, or has it no more for a delete. */
+{
+    status: "pushed";
+    branch: string;
+}
+/** No central remote is configured, so nothing was pushed. */
+ | {
+    status: "off";
+}
+/** Refused before git was asked, for `why`. */
+ | {
+    status: "refused";
+    why: string;
+}
+/** Git or GitHub refused it, saying `why`. */
+ | {
+    status: "failed";
+    why: string;
+};
+/** What mints a task's tokens: the GitHub App, or a server that keeps it. */
+export type TokenMinter = Pick<GitHubApp, "token">;
+/** Where `TaskBranches` finds what it mints tokens with. */
+export interface AppSource {
+    /** The App, or null when its creds are not kept. */
+    app(): Promise<TokenMinter | null>;
+}
+/** Where `TaskBranches` reads a task's branch, for a push, a delete or a sign-in. */
+export interface BranchOptions {
+    /** The repository the branch is in: the main tree's by default, or a clone's. */
+    at?: Git;
+    /** Push to `splates/<as>` rather than `splates/<task>`; a `push` only. */
+    as?: string;
+}
+/** What `TaskBranches.of` reaches GitHub through; the global `fetch` by default. */
+export interface TaskBranchesOptions {
+    fetch?: typeof fetch;
+}
+/** Where a push goes and what it signs in with. */
+export interface Target {
+    /** A remote's name, or a URL. */
+    to: string;
+    /** The URL it fetches from, which a clone is made from. */
+    url: string;
+    /** Added to git's environment, carrying a token when there is one. */
+    env: Record<string, string>;
+}
+/**
+ * Each task's branch on the project's central remote, `config.remote`, as
+ * `splates/<task>`: pushed after every commit and at every checkpoint, so a
+ * task outlives the machine it runs on, and deleted once it merges or is
+ * removed. Nothing here ever pushes anything but a `splates/*` branch, and
+ * a branch that tracks `SPLATES.md` is never pushed at all.
+ *
+ * With the GitHub App's creds kept, it pushes with a token the App mints per
+ * task, good for an hour and for this repository's contents alone; without
+ * them, with this machine's own git credentials.
+ */
+export declare class TaskBranches {
+    private readonly git;
+    /** Names the remote, `remote`, read at each push; null pushes nothing. */
+    private readonly config;
+    private readonly apps;
+    /** Where a pushed task's plan is kept beside its branch; none keeps no plans. */
+    private readonly plans;
+    /** By task, the token it pushes with until it nears its expiry. */
+    private readonly tokens;
+    /**
+     * By task, its last push or delete, which the next waits for: two pushes
+     * racing could leave the older last, and the remote behind.
+     */
+    private readonly last;
+    constructor(git: Git, 
+    /** Names the remote, `remote`, read at each push; null pushes nothing. */
+    config: Pick<Config, "remote">, apps: AppSource, 
+    /** Where a pushed task's plan is kept beside its branch; none keeps no plans. */
+    plans?: PlanStore | null);
+    /** The project's, pushing to its configured remote with its kept creds. */
+    static of({ git, config, creds, plans, }: {
+        git: Git;
+        config: Config;
+        creds: Creds;
+        plans?: PlanStore;
+    }, opts?: TaskBranchesOptions): TaskBranches;
+    /** The remote's name, or null when none is configured. */
+    remote(): string | null;
+    /** The branch `task` is pushed as. */
+    pushedBranch(task: string): string;
+    /**
+     * Pushes `branch`, the task's own, to the remote as `splates/<task>`,
+     * replacing what is there, since a task's branch is rebased and squashed
+     * as it goes. Run while a rebase is under way, it pushes the branch as it
+     * stood before the rebase.
+     */
+    push(task: string, branch: string, opts?: BranchOptions): Promise<Pushed>;
+    /** Writes the plan kept for `tree`'s task into it when it has none: false when nothing was written. */
+    restorePlan(tree: Pick<Worktree, "task" | "path">): Promise<boolean>;
+    /** Pushes a task's own branch from its checkout, a worktree or a clone, as `push` does. */
+    pushTree(tree: Pick<Worktree, "task" | "branch" | "git">): Promise<Pushed>;
+    /** Deletes `splates/<task>` from the remote; one already gone is deleted too. */
+    delete(task: string, opts?: BranchOptions): Promise<Pushed>;
+    /**
+     * Fetches the remote's `trunk` into `refs/remotes/<remote>/<trunk>`,
+     * signing in as `task`'s pushes do, and gives the commit it is at: what a
+     * merge rebases onto, since only the server moves trunk there.
+     */
+    fetchTrunk(task: string, trunk: string, cwd: string): Promise<{
+        status: "fetched";
+        commit: string;
+    } | Exclude<Pushed, {
+        status: "pushed";
+    }>>;
+    /**
+     * Where `task`'s branch is pushed and fetched, signing in with a token
+     * of its own when the App is kept; null when no remote is configured.
+     * Read in `at`, the repository the task's branch is in. A null `task`
+     * signs in for the project's own checkout, with a token minted afresh.
+     */
+    signIn(task: string | null, opts?: BranchOptions): Promise<Target | null>;
+    /**
+     * A token of the App's for the project's own repository, as the
+     * server mints one for a worker's git; null when the App is not
+     * kept or the remote is not on github.com. Never for any other
+     * repository, whatever the worker asks.
+     */
+    mint(): Promise<InstallationToken | null>;
+    private run;
+    private runNow;
+    /**
+     * The App's https URL for the remote, signing in with a token of `task`'s,
+     * when the App is kept and the remote is on github.com; the remote itself
+     * otherwise, signing in as this machine does.
+     */
+    private target;
+}
+/** Where `remote`'s `trunk` is kept once fetched. */
+export declare function trackingRef(remote: string, trunk: string): string;
+/**
+ * The line a command's report gives a push or a delete, `what` saying which:
+ * none when no remote is configured, and what stopped it when it failed.
+ */
+export declare function pushedLine(pushed: Pushed, what: "pushed" | "deleted"): string | null;

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

@@ -0,0 +1,18 @@
+import type { FailedTest, GateFailure } from "../tasks";
+/**
+ * Whether a failing gate repeats the task's last `tests_failed`: on the same
+ * base commit, or with the same failing tests on any base. A repeat spends a
+ * merge attempt; a failure on a base the task was never gated on is new
+ * information and spends none.
+ */
+export declare function repeatsFailure(last: GateFailure | undefined, rebasedOnto: string, failed: FailedTest[] | undefined): "base" | "tests" | null;
+/** The line of a `tests_failed` saying whether it spent a merge attempt, and why. */
+export declare function chargeLine(of: {
+    charged: boolean;
+    taskFailed: boolean;
+    repeat: "base" | "tests" | null;
+    first: boolean;
+    base: string;
+    onto: string;
+    attribution: string | undefined;
+}): string;

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

@@ -0,0 +1,7 @@
+import type { WorktreeService } from "../tasks";
+/**
+ * Takes `gate`, `mergeSince`, `mergePlace` and `mergeSteps` off the task's record once its merge ends, landed or not, so
+ * a later lease on it shows no merge under way. A landed task has no record
+ * left to change.
+ */
+export declare function clearGate(service: WorktreeService, task: string): Promise<void>;

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

@@ -0,0 +1,60 @@
+import type { Fs, Ps } from "../../../core/system/index.js";
+import { Duration, type WallClock } from "../../../core/time/index.js";
+/** How long a load that has ended goes on showing in the one-minute load average, at 1/e of its height after this. */
+export declare const LOAD_LAG: Duration;
+/**
+ * The test workers to give a merge's gate on a machine of `cores` with
+ * `load` the person's: the cores it leaves idle, at most all but two and at
+ * least half.
+ */
+export declare function gateCores(cores: number, load: number): number;
+/** The most a gate's deadline may stretch to under load, as a multiple of its base. */
+export declare const DEADLINE_STRETCH = 2;
+/**
+ * How long a gate of `workers` may run on `cores` with `load` the person's:
+ * `baseMs` when they all fit the cores, and longer by the share they
+ * oversubscribe them, up to `DEADLINE_STRETCH` times.
+ */
+export declare function gateDeadline(baseMs: number, { cores, load, workers }: GateSizing): number;
+/** What a gate starting now is sized by. */
+export interface GateSizing {
+    /** The test workers it may run. */
+    workers: number;
+    cores: number;
+    /** The one-minute load average less what the gate before still adds to it. */
+    load: number;
+}
+/**
+ * What a run of `workers` that took `ran`, and ended `since` ago, still adds
+ * to the one-minute load average: the share it had built up by its end,
+ * decayed since.
+ */
+export declare function lingering({ workers, ran, since, }: {
+    workers: number;
+    ran: Duration;
+    since: Duration;
+}): number;
+/**
+ * Sizes each merge gate by the person's load on the machine, leaving out
+ * what the gate before it still adds to the one-minute average. Make one
+ * with `ofMachine`, ask `sizing` for a gate about to run and tell `ran`
+ * once it has.
+ */
+export declare class GateTrail {
+    #private;
+    private readonly fs;
+    private readonly path;
+    private readonly sensors;
+    private readonly wall;
+    constructor(fs: Fs, path: string, sensors: {
+        cores(): number;
+        loadavg(): number[];
+    }, wall?: WallClock);
+    static ofMachine(fs: Fs, ps: Ps): GateTrail;
+    /** The workers a gate starting now may run. */
+    size(): Promise<number>;
+    /** The workers a gate starting now may run, with the cores and load they were sized by. */
+    sizing(): Promise<GateSizing>;
+    /** Keeps a run of `workers` that took `ran` and has just ended, for the next gate to size by. */
+    ran(workers: number, ran: Duration): Promise<void>;
+}

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

@@ -0,0 +1,28 @@
+import type { Event } from "../records";
+import { type MergeStep } from "../tasks";
+/** How many of the project's last landed merges the typical times come from. */
+export declare const ESTIMATED_FROM = 20;
+/** How long each step and premerge phase of a merge usually takes here. */
+export interface MergeEstimates {
+    /** The median milliseconds of each step; a step no recent merge timed is left out. */
+    steps: Partial<Record<MergeStep, number>>;
+    /**
+     * The median milliseconds of each phase the premerge times, in the order
+     * the last gate ran them, each with the phase it runs inside of, if any.
+     */
+    phases: {
+        phase: string;
+        ms: number;
+        within?: string;
+    }[];
+    /** How many landed merges they come from. */
+    merges: number;
+}
+/**
+ * The typical times of the last `ESTIMATED_FROM` merges that landed among
+ * `events`, oldest first. The wait for the premerge lock is what each gated
+ * merge kept of it, and a merge from before steps were timed still gives its
+ * gate's time. `setup`, the time a
+ * gate's phases leave, is no phase the page sees start, so it is left out.
+ */
+export declare function mergeEstimates(events: readonly Event[]): MergeEstimates;

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

@@ -0,0 +1,43 @@
+import { type Logger } from "../../../core/log/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 } from "../records";
+import type { DiffSize, Worktree, WorktreeService } from "../tasks";
+import { type TaskBranches } from "./branches";
+import type { TimedTest } from "./test-report";
+import type { MergeTiming } from "./timing";
+import type { Landed } from "./trunk";
+/** What a merge landed, as `finishLanding` ends it with. */
+export interface Landing {
+    /** The task's checkout, about to go. */
+    current: Worktree;
+    /** The commit the task landed as, short. */
+    head: string;
+    /** The checkout the base is checked out in, where it moved. */
+    landing: string;
+    /** The remote landing, or null for a local one. */
+    landed: Extract<Landed, {
+        status: "landed";
+    }> | null;
+    changed: string[];
+    commits: string[] | undefined;
+    size: DiffSize | undefined;
+    testTimes: TimedTest[];
+}
+/**
+ * Ends a merge whose work is on the base: discards the worktree, frees its
+ * slot, drops any pushed branch, takes the queued tasks it took off the list
+ * and says what to report. A batch's followers end here as its leader does.
+ */
+export declare function finishLanding({ service, git, config, log, tasks, slots, branches, timing, }: {
+    service: WorktreeService;
+    git: Git;
+    config: Config;
+    log: Logger;
+    tasks: Tasks;
+    slots: Slots;
+    branches: TaskBranches;
+    timing: MergeTiming;
+}, landing: Landing, facts: Partial<Facts["merge"]>): Promise<void>;

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

@@ -0,0 +1,50 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Git } from "../git";
+import type { MergeBatch, Settled } from "./batch";
+/** What following came to: the lock, to lead, or a batch's result. */
+export type Followed = {
+    capacity: AsyncDisposable;
+} | {
+    result: Settled;
+} | {
+    doomed: true;
+};
+/**
+ * Waits for the premerge lock as a merge offered to any batch, and says
+ * what came of it: the result of a batch that landed or refused the branch,
+ * `{ doomed: true }` once `doomed` answers true while the branch is on no
+ * stack, or the lock, which makes this merge the next leader. The branch is
+ * left on `ownHead` unless a batch landed it.
+ */
+export declare function follow({ batch, git, log, pollMs, doomed, }: {
+    batch: MergeBatch;
+    git: Git;
+    log: Logger;
+    pollMs?: number;
+    doomed?: () => Promise<boolean>;
+}, { task, path, ownHead, requireLease, onStacked, onUnstacked, }: {
+    task: string;
+    path: string;
+    /** The branch's tip rebased on the base alone, which every stacking starts from. */
+    ownHead: string;
+    requireLease: () => Promise<unknown>;
+    /** Called once the branch is on a batch's stack, whose gate is this merge's. */
+    onStacked: () => Promise<void>;
+    /**
+     * Called when a batch let the branch go, back on `ownHead`: to wait
+     * on once the batch `dissolved`, or refused by its result otherwise.
+     */
+    onUnstacked: (dissolved: boolean) => Promise<void>;
+}, reserve: (signal: AbortSignal) => Promise<AsyncDisposable>): Promise<Followed>;
+/**
+ * Waits for the premerge lock as a merge offered to no batch. `doomed`,
+ * asked every `pollMs`, ends the wait with `{ doomed: true }` once it
+ * answers true.
+ */
+export declare function waitAlone(reserve: (signal: AbortSignal) => Promise<AsyncDisposable>, doomed?: () => Promise<boolean>, pollMs?: number): Promise<Followed>;
+/**
+ * Asks whether `base`, once it moves past `seen`, conflicts with the
+ * branch's tip `head`: true only for a merge that would conflict, so a
+ * wait it ends never lets anything through.
+ */
+export declare function conflictsOnBase(git: Git, base: string, seen: string | null, head: string): () => Promise<boolean>;