pr-merge-queue 0.0.0-stage → 0.0.0

package/dist/unblock-prs/merge-after.d.mts

@@ -0,0 +1,46 @@
+/**
+ * What the declared order means for picking a pull request, as a note, and
+ * the order the issues the pull requests close add to it. Reading the
+ * `Merge-After:` trailers and the `Start-After:` lines, finding the cycles in
+ * them and deciding that a pull request waits is `pr-report-core`'s, because
+ * the Pull Requests Manager page draws the same queue.
+ */
+import { type RepoRef } from 'pr-report-core';
+import type { Classification, IssueOrder, PullRequest } from './types.mjs';
+/**
+ * The note to report instead of picking this pull request while what it
+ * must merge after is still open. Picking is all this constrains: a pull
+ * request that is already up to date and merging is left to auto-merge,
+ * which takes no notice of anything declared here.
+ */
+export declare const waitingOnNote: (pr: PullRequest, on: readonly number[], cyclic: boolean, inherited?: readonly number[]) => Classification;
+/** One issue as the closing-issue reads answer it. */
+export type ClosingIssueAnswer = Readonly<{
+    number: number;
+    /** `OPEN` or `CLOSED`. */
+    state: string;
+    body: string;
+    /** The issues of this repository GitHub records as blocking it. */
+    blockedBy: readonly number[];
+}>;
+/**
+ * Which open issues each pull request closes, and what those declare with
+ * `Start-After:`, for `queueGraph` to inherit.
+ *
+ * An issue closes when GitHub links it (`linked`, this repository's only) or
+ * when the body closes it by keyword, as GitHub marked it in `bodyHtml` —
+ * the one way to tell for a stacked pull request, which GitHub links
+ * nothing on. `described` is what was read of the keyword ones GitHub did
+ * not link; one it would not describe is left out, being unknown.
+ */
+export declare const issueOrderOf: (repo: RepoRef, pulls: readonly Readonly<{
+    number: number;
+    bodyHtml: string;
+    linked: readonly ClosingIssueAnswer[];
+}>[], described: ReadonlyMap<number, ClosingIssueAnswer>) => IssueOrder;
+/** The keyword-closed issues of `pulls` that GitHub did not link. */
+export declare const unlinkedClosingIssues: (repo: RepoRef, pulls: readonly Readonly<{
+    bodyHtml: string;
+    linked: readonly ClosingIssueAnswer[];
+}>[]) => readonly number[];
+//# sourceMappingURL=merge-after.d.mts.map

package/dist/unblock-prs/merge-after.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-after.d.mts","sourceRoot":"","sources":["../../src/unblock-prs/merge-after.mts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAoC,KAAK,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAEhF,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE3E;;;;;GAKG;AACH,eAAO,MAAM,aAAa,OACpB,WAAW,MACX,SAAS,MAAM,EAAE,UACb,OAAO,cACJ,SAAS,MAAM,EAAE,KAC3B,cAeF,CAAC;AAEF,sDAAsD;AACtD,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,0BAA0B;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9B,CAAC,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,SACjB,OAAO,SACN,SAAS,QAAQ,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,SAAS,kBAAkB,EAAE,CAAC;CACvC,CAAC,EAAE,aACO,WAAW,CAAC,MAAM,EAAE,kBAAkB,CAAC,KACjD,UA6BF,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,qBAAqB,SAC1B,OAAO,SACN,SAAS,QAAQ,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,SAAS,kBAAkB,EAAE,CAAC;CACvC,CAAC,EAAE,KACH,SAAS,MAAM,EAUjB,CAAC"}

package/dist/unblock-prs/merge-after.mjs

@@ -0,0 +1,65 @@
+
+
+
+
+
+
+
+import { closingKeywordIssuesIn, waitsFor } from 'pr-report-core';
+import { Arr } from 'ts-data-forge';
+
+
+
+
+
+
+export const waitingOnNote = (pr, on, cyclic, inherited = []) => {
+    const fromIssues = on.filter((number) => inherited.includes(number));
+    return {
+        kind: 'note',
+        note: `#${pr.number}: Merge-After ${on.map((number) => `#${number}`).join(', ')}, still open${Arr.isNonEmpty(fromIssues)
+            ? ` (${fromIssues.map((number) => `#${number}`).join(', ')} from the Start-After of an issue it closes)`
+            : ''}${cyclic
+            ? ' — and on a Merge-After cycle, so nothing here will move it'
+            : ''}`,
+    };
+};
+
+
+
+
+
+
+
+
+
+
+export const issueOrderOf = (repo, pulls, described) => {
+    const mut_issues = new Map(described);
+    for (const issue of pulls.flatMap(({ linked }) => linked)) {
+        mut_issues.set(issue.number, issue);
+    }
+    const issues = mut_issues;
+    const isOpen = (number) => issues.get(number)?.state.toUpperCase() === 'OPEN';
+    return {
+        closes: new Map(pulls.map(({ number, bodyHtml, linked }) => [
+            number,
+            Arr.uniq([
+                ...linked.map((issue) => issue.number),
+                ...closingKeywordIssuesIn(repo, bodyHtml),
+            ]).filter(isOpen),
+        ])),
+        startAfter: new Map(Array.from(issues.values(), ({ number, body, blockedBy }) => [
+            number,
+            waitsFor(body, blockedBy),
+        ])),
+    };
+};
+
+export const unlinkedClosingIssues = (repo, pulls) => {
+    const linked = new Set(pulls.flatMap((pull) => pull.linked.map(({ number }) => number)));
+    return Arr.uniq(pulls.flatMap(({ bodyHtml }) => closingKeywordIssuesIn(repo, bodyHtml)))
+        .filter((number) => !linked.has(number))
+        .toSorted((a, b) => a - b);
+};
+//# sourceMappingURL=merge-after.mjs.map

package/dist/unblock-prs/merge-after.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-after.mjs","sourceRoot":"","sources":["../../src/unblock-prs/merge-after.mts"],"names":[],"mappings":"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"}

package/dist/unblock-prs/options.d.mts

@@ -0,0 +1,35 @@
+/** What the command line says, and how it is read. */
+import { Result } from 'ts-data-forge';
+export type Options = Readonly<{
+    /** Run one cycle — survey, act on one pull request, report — and exit. */
+    once: boolean;
+    /** Survey and say what would be done, without rebasing or pushing. */
+    dryRun: boolean;
+    /** How long to wait between surveys while the list is still changing. */
+    activeIntervalSec: number;
+    /**
+     * How many surveys in a row must see an unchanged list before the wait
+     * between them grows to `idleIntervalSec`.
+     */
+    idleAfter: number;
+    /** How long to wait between surveys once the list has sat still. */
+    idleIntervalSec: number;
+    /** How often to poll the pull request being watched. */
+    pollIntervalSec: number;
+    /** How long to watch one pull request before giving up on it. */
+    watchTimeoutMin: number;
+    /**
+     * Whether a watched pull request whose failure is only a fixer's diff has
+     * the fixer run, amended onto its commit and pushed. See `auto-fix.mts`.
+     */
+    autoFix: boolean;
+    /**
+     * The repository, `owner/name`, when it is not the one `origin` names
+     * (`lib/github-api.mts`'s `resolveRepo`).
+     */
+    repo: string | undefined;
+}>;
+export declare const defaultOptions: Options;
+export declare const HELP: string;
+export declare const parseOptions: (args: readonly string[]) => Result<Options | 'help', string>;
+//# sourceMappingURL=options.d.mts.map

package/dist/unblock-prs/options.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.mts","sourceRoot":"","sources":["../../src/unblock-prs/options.mts"],"names":[],"mappings":"AAAA,sDAAsD;AAGtD,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAGvC,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC;IAC7B,0EAA0E;IAC1E,IAAI,EAAE,OAAO,CAAC;IACd,sEAAsE;IACtE,MAAM,EAAE,OAAO,CAAC;IAChB,yEAAyE;IACzE,iBAAiB,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,eAAe,EAAE,MAAM,CAAC;IACxB,wDAAwD;IACxD,eAAe,EAAE,MAAM,CAAC;IACxB,iEAAiE;IACjE,eAAe,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B,CAAC,CAAC;AAEH,eAAO,MAAM,cAAc,EAAE,OAUnB,CAAC;AAEX,eAAO,MAAM,IAAI,QAoBL,CAAC;AAEb,eAAO,MAAM,YAAY,SACjB,SAAS,MAAM,EAAE,KACtB,MAAM,CAAC,OAAO,GAAG,MAAM,EAAE,MAAM,CAoFjC,CAAC"}

package/dist/unblock-prs/options.mjs

@@ -0,0 +1,88 @@
+
+import { MERGE_QUEUED_LABEL, SKIP_CI_LABEL } from 'pr-report-core';
+import { Result } from 'ts-data-forge';
+import { parseCommandArgs, positiveInteger } from '../lib/index.mjs';
+export const defaultOptions = {
+    once: false,
+    dryRun: false,
+    activeIntervalSec: 30,
+    idleAfter: 10,
+    idleIntervalSec: 300,
+    pollIntervalSec: 30,
+    watchTimeoutMin: 90,
+    autoFix: true,
+    repo: undefined,
+};
+export const HELP = [
+    'Usage: unblock-prs [options]',
+    '',
+    `Takes the ${MERGE_QUEUED_LABEL} pull requests in the order they declare with`,
+    '`Merge-After:`, one at a time: rebases the one that is out of date with the',
+    `default branch, takes ${SKIP_CI_LABEL} off it, and waits for GitHub to merge it.`,
+    'When its checks fail only because a fix: or gen: entry of the check matrices',
+    'left a diff, runs that command, amends the result and pushes it, once.',
+    '',
+    'Options:',
+    '  --once                   run one cycle and exit',
+    '  --dry-run                survey and report what would be done, then exit',
+    `  --active-interval <sec>  wait between surveys while the list is changing (default ${defaultOptions.activeIntervalSec})`,
+    `  --idle-after <n>         unchanged surveys before slowing to --idle-interval (default ${defaultOptions.idleAfter})`,
+    `  --idle-interval <sec>    wait between surveys once the list has sat still (default ${defaultOptions.idleIntervalSec})`,
+    `  --poll-interval <sec>    wait between polls of the watched pull request (default ${defaultOptions.pollIntervalSec})`,
+    `  --watch-timeout <min>    give up on a pull request after this long (default ${defaultOptions.watchTimeoutMin})`,
+    "  --no-auto-fix            leave a failure that is only a fixer's diff as it is",
+    '  --repo <owner/name>      the repository, when origin does not name it',
+    '  -h, --help               show this help',
+].join('\n');
+export const parseOptions = (args) => {
+    const parsed = parseCommandArgs(args, {
+        once: { type: 'boolean', default: false },
+        'dry-run': { type: 'boolean', default: false },
+        'active-interval': { type: 'string' },
+        'idle-after': { type: 'string' },
+        'idle-interval': { type: 'string' },
+        'poll-interval': { type: 'string' },
+        'watch-timeout': { type: 'string' },
+        'no-auto-fix': { type: 'boolean', default: false },
+        repo: { type: 'string' },
+    });
+    if (Result.isErr(parsed)) {
+        return parsed;
+    }
+    if (parsed.value === 'help') {
+        return Result.ok('help');
+    }
+    const values = parsed.value;
+    const activeIntervalSec = positiveInteger('active-interval', values['active-interval'], defaultOptions.activeIntervalSec);
+    if (Result.isErr(activeIntervalSec)) {
+        return activeIntervalSec;
+    }
+    const idleAfter = positiveInteger('idle-after', values['idle-after'], defaultOptions.idleAfter);
+    if (Result.isErr(idleAfter)) {
+        return idleAfter;
+    }
+    const idleIntervalSec = positiveInteger('idle-interval', values['idle-interval'], defaultOptions.idleIntervalSec);
+    if (Result.isErr(idleIntervalSec)) {
+        return idleIntervalSec;
+    }
+    const pollIntervalSec = positiveInteger('poll-interval', values['poll-interval'], defaultOptions.pollIntervalSec);
+    if (Result.isErr(pollIntervalSec)) {
+        return pollIntervalSec;
+    }
+    const watchTimeoutMin = positiveInteger('watch-timeout', values['watch-timeout'], defaultOptions.watchTimeoutMin);
+    if (Result.isErr(watchTimeoutMin)) {
+        return watchTimeoutMin;
+    }
+    return Result.ok({
+        once: values.once,
+        dryRun: values['dry-run'],
+        activeIntervalSec: activeIntervalSec.value,
+        idleAfter: idleAfter.value,
+        idleIntervalSec: idleIntervalSec.value,
+        pollIntervalSec: pollIntervalSec.value,
+        watchTimeoutMin: watchTimeoutMin.value,
+        autoFix: !values['no-auto-fix'],
+        repo: values.repo,
+    });
+};
+//# sourceMappingURL=options.mjs.map

package/dist/unblock-prs/options.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.mjs","sourceRoot":"","sources":["../../src/unblock-prs/options.mts"],"names":[],"mappings":"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"}

package/dist/unblock-prs/owner.d.mts

@@ -0,0 +1,32 @@
+/**
+ * Who moves each pull request next, as the worker reads it: `pr-report-core`'s
+ * `queueOwner`, the one function `pr-report`, `claim-pr` and every other
+ * command a session runs read it through, given the facts GitHub returned.
+ *
+ * The set-aside comes from the records, which by the time triage reads them
+ * are what this account's comments say (`settleSkips`): a record the base
+ * moved under is pruned as its comment is rewritten as resolved, and one an
+ * earlier run left is taken up from its comment. The claims are the ones
+ * that still hold (`claims.mts`).
+ */
+import { type Claim, type QueueOwner } from 'pr-report-core';
+import type { Classification, PullRequest, SkipRecords } from './types.mjs';
+export type OwnerContext = Readonly<{
+    defaultBranch: string;
+    skipped: SkipRecords;
+    claimed: ReadonlyMap<number, Claim>;
+    /** Which open pull request each stacked one is on: child → parent. */
+    stackParents: ReadonlyMap<number, number>;
+    /** Every number that sits on a `Merge-After` cycle. */
+    cyclic: ReadonlySet<number>;
+    nowEpochMs: number;
+}>;
+/** Who moves `pr` next, or `undefined` outside the queue. */
+export declare const ownerOf: (pr: PullRequest, context: OwnerContext) => QueueOwner | undefined;
+/**
+ * What triage says about a pull request that is not the worker's to move: a
+ * note naming its owner and why, with the record's detail when one set it
+ * aside. `undefined` for one the worker moves, or one outside the queue.
+ */
+export declare const ownerNote: (pr: PullRequest, owner: QueueOwner | undefined, skipped: SkipRecords) => Classification | undefined;
+//# sourceMappingURL=owner.d.mts.map

package/dist/unblock-prs/owner.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"owner.d.mts","sourceRoot":"","sources":["../../src/unblock-prs/owner.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAc,KAAK,KAAK,EAAE,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACzE,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE5E,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,WAAW,CAAC;IACrB,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACpC,sEAAsE;IACtE,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,uDAAuD;IACvD,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC,CAAC;AAEH,6DAA6D;AAC7D,eAAO,MAAM,OAAO,OACd,WAAW,WACN,YAAY,KACpB,UAAU,GAAG,SA+Bf,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,SAAS,OAChB,WAAW,SACR,UAAU,GAAG,SAAS,WACpB,WAAW,KACnB,cAAc,GAAG,SAkBnB,CAAC"}

package/dist/unblock-prs/owner.mjs

@@ -0,0 +1,63 @@
+
+
+
+
+
+
+
+
+
+
+
+import { queueOwner } from 'pr-report-core';
+
+export const ownerOf = (pr, context) => {
+    const skip = context.skipped.get(pr.number);
+    const claim = context.claimed.get(pr.number);
+    return queueOwner({
+        number: pr.number,
+        labels: pr.labels.map(({ name }) => name),
+        isDraft: pr.isDraft,
+        fromFork: pr.isCrossRepository,
+        headRef: pr.headRefName,
+        headSha: pr.headRefOid,
+        baseRef: pr.baseRefName,
+        defaultBranch: context.defaultBranch,
+        stackedOn: context.stackParents.get(pr.number),
+        inCycle: context.cyclic.has(pr.number),
+        setAside: skip === undefined
+            ? undefined
+            : {
+                kind: 'standing',
+                setAside: {
+                    reason: skip.reason,
+                    headSha: skip.headSha,
+                    baseSha: skip.baseSha,
+                },
+                retry: false,
+            },
+        claim: claim === undefined ? undefined : { kind: 'standing', claim },
+        nowEpochMs: context.nowEpochMs,
+    });
+};
+
+
+
+
+
+export const ownerNote = (pr, owner, skipped) => {
+    if (owner === undefined || owner.owner === 'worker') {
+        return undefined;
+    }
+    const skip = skipped.get(pr.number);
+    const whose = owner.owner === 'skill'
+        ? "the /unblock-prs skill's"
+        : owner.owner === 'human'
+            ? "a person's"
+            : "nobody's — a bug";
+    return {
+        kind: 'note',
+        note: `#${pr.number}: ${whose} (${owner.reason})${skip === undefined ? '' : `; set aside: ${skip.detail}`}`,
+    };
+};
+//# sourceMappingURL=owner.mjs.map

package/dist/unblock-prs/owner.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"owner.mjs","sourceRoot":"","sources":["../../src/unblock-prs/owner.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,UAAU,EAA+B,MAAM,gBAAgB,CAAC;AAczE,6DAA6D;AAC7D,MAAM,CAAC,MAAM,OAAO,GAAG,CACrB,EAAe,EACf,OAAqB,EACG,EAAE;IAC1B,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC;IAE5C,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC;IAE7C,OAAO,UAAU,CAAC;QAChB,MAAM,EAAE,EAAE,CAAC,MAAM;QACjB,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC;QACzC,OAAO,EAAE,EAAE,CAAC,OAAO;QACnB,QAAQ,EAAE,EAAE,CAAC,iBAAiB;QAC9B,OAAO,EAAE,EAAE,CAAC,WAAW;QACvB,OAAO,EAAE,EAAE,CAAC,UAAU;QACtB,OAAO,EAAE,EAAE,CAAC,WAAW;QACvB,aAAa,EAAE,OAAO,CAAC,aAAa;QACpC,SAAS,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC;QAC9C,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC;QACtC,QAAQ,EACN,IAAI,KAAK,SAAS;YAChB,CAAC,CAAC,SAAS;YACX,CAAC,CAAC;gBACE,IAAI,EAAE,UAAU;gBAChB,QAAQ,EAAE;oBACR,MAAM,EAAE,IAAI,CAAC,MAAM;oBACnB,OAAO,EAAE,IAAI,CAAC,OAAO;oBACrB,OAAO,EAAE,IAAI,CAAC,OAAO;iBACtB;gBACD,KAAK,EAAE,KAAK;aACb;QACP,KAAK,EAAE,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE;QACpE,UAAU,EAAE,OAAO,CAAC,UAAU;KAC/B,CAAC,CAAC;AACL,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CACvB,EAAe,EACf,KAA6B,EAC7B,OAAoB,EACQ,EAAE;IAC9B,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;QACpD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC;IAEpC,MAAM,KAAK,GACT,KAAK,CAAC,KAAK,KAAK,OAAO;QACrB,CAAC,CAAC,0BAA0B;QAC5B,CAAC,CAAC,KAAK,CAAC,KAAK,KAAK,OAAO;YACvB,CAAC,CAAC,YAAY;YACd,CAAC,CAAC,kBAAkB,CAAC;IAE3B,OAAO;QACL,IAAI,EAAE,MAAM;QACZ,IAAI,EAAE,IAAI,EAAE,CAAC,MAAM,KAAK,KAAK,KAAK,KAAK,CAAC,MAAM,IAAI,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,IAAI,CAAC,MAAM,EAAE,EAAE;KAC5G,CAAC;AACJ,CAAC,CAAC"}

package/dist/unblock-prs/quiet.d.mts

@@ -0,0 +1,21 @@
+/**
+ * How long the loop sleeps when there is nothing to do: briefly while the
+ * list is still changing, so a pull request queued a moment ago is picked up
+ * in seconds, and at the idle interval once it has sat still for a while.
+ */
+import type { StrictPick } from 'ts-type-forge';
+import type { Options } from './options.mjs';
+import type { Quiet, Survey } from './types.mjs';
+export declare const initialQuiet: Quiet;
+/**
+ * The part of a survey triage reads: the base, and for every open pull
+ * request its head, merge state, labels, auto-merge, draft flag and body —
+ * the body because that is where `Merge-After:` is declared — and what the
+ * reviews hold, which triage reads separately: an approval or a resolved
+ * conversation is exactly what a held pull request is waiting for. The title
+ * is left out, as is the order GitHub lists things in.
+ */
+export declare const surveyFingerprint: (survey: StrictPick<Survey, 'baseSha' | 'pullRequests'>, reviewHolds?: readonly string[]) => string;
+export declare const observeSurvey: (quiet: Quiet, fingerprint: string) => Quiet;
+export declare const idleWaitSec: (quiet: Quiet, options: StrictPick<Options, 'activeIntervalSec' | 'idleAfter' | 'idleIntervalSec'>) => number;
+//# sourceMappingURL=quiet.d.mts.map

package/dist/unblock-prs/quiet.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quiet.d.mts","sourceRoot":"","sources":["../../src/unblock-prs/quiet.mts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAEjD,eAAO,MAAM,YAAY,EAAE,KAGjB,CAAC;AAEX;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,WACpB,UAAU,CAAC,MAAM,EAAE,SAAS,GAAG,cAAc,CAAC,gBACzC,SAAS,MAAM,EAAE,KAC7B,MAgBC,CAAC;AAEL,eAAO,MAAM,aAAa,UAAW,KAAK,eAAe,MAAM,KAAG,KAKrD,CAAC;AAEd,eAAO,MAAM,WAAW,UACf,KAAK,WACH,UAAU,CACjB,OAAO,EACP,mBAAmB,GAAG,WAAW,GAAG,iBAAiB,CACtD,KACA,MAG4B,CAAC"}

package/dist/unblock-prs/quiet.mjs

@@ -0,0 +1,42 @@
+
+
+
+
+
+import { isRecord } from 'ts-data-forge';
+export const initialQuiet = {
+    fingerprint: undefined,
+    unchanged: 0,
+};
+
+
+
+
+
+
+
+
+export const surveyFingerprint = (survey, reviewHolds = []) => JSON.stringify({
+    baseSha: survey.baseSha,
+    reviewHolds: reviewHolds.toSorted(),
+    pullRequests: survey.pullRequests
+        .toSorted((a, b) => a.number - b.number)
+        .map((pr) => [
+        pr.number,
+        pr.headRefOid,
+        pr.baseRefName,
+        pr.mergeStateStatus,
+        pr.isDraft,
+        isRecord(pr.autoMergeRequest),
+        pr.labels.map((label) => label.name).toSorted(),
+        pr.body,
+    ]),
+});
+export const observeSurvey = (quiet, fingerprint) => ({
+    fingerprint,
+    unchanged: quiet.fingerprint === fingerprint ? quiet.unchanged + 1 : 0,
+});
+export const idleWaitSec = (quiet, options) => quiet.unchanged >= options.idleAfter
+    ? options.idleIntervalSec
+    : options.activeIntervalSec;
+//# sourceMappingURL=quiet.mjs.map

package/dist/unblock-prs/quiet.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"quiet.mjs","sourceRoot":"","sources":["../../src/unblock-prs/quiet.mts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAKzC,MAAM,CAAC,MAAM,YAAY,GAAU;IACjC,WAAW,EAAE,SAAS;IACtB,SAAS,EAAE,CAAC;CACJ,CAAC;AAEX;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,MAAsD,EACtD,WAAW,GAAsB,EAAE,EAC3B,EAAE,CACV,IAAI,CAAC,SAAS,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,OAAO;IACvB,WAAW,EAAE,WAAW,CAAC,QAAQ,EAAE;IACnC,YAAY,EAAE,MAAM,CAAC,YAAY;SAC9B,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;SACvC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC;QACX,EAAE,CAAC,MAAM;QACT,EAAE,CAAC,UAAU;QACb,EAAE,CAAC,WAAW;QACd,EAAE,CAAC,gBAAgB;QACnB,EAAE,CAAC,OAAO;QACV,QAAQ,CAAC,EAAE,CAAC,gBAAgB,CAAC;QAC7B,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE;QAC/C,EAAE,CAAC,IAAI;KACR,CAAC;CACL,CAAC,CAAC;AAEL,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,KAAY,EAAE,WAAmB,EAAS,EAAE,CACxE,CAAC;IACC,WAAW;IACX,SAAS,EACP,KAAK,CAAC,WAAW,KAAK,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAE,CAAW;CACzE,CAAU,CAAC;AAEd,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,KAAY,EACZ,OAGC,EACO,EAAE,CACV,KAAK,CAAC,SAAS,IAAI,OAAO,CAAC,SAAS;IAClC,CAAC,CAAC,OAAO,CAAC,eAAe;IACzB,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC"}

package/dist/unblock-prs/rebase.d.mts

@@ -0,0 +1,120 @@
+import { type QueueOwner } from 'pr-report-core';
+import { Result } from 'ts-data-forge';
+import { type ApiContext } from '../lib/index.mjs';
+import type { Advanced, AdvancePlan, BranchOf, PullRequest, RebaseFailure, SkipRecords, StackedOn } from './types.mjs';
+/**
+ * Force-pushes `sha` to `branch`, leased against `lease`: `moved` when the
+ * lease lost to someone else's push, an error when the push was refused for
+ * any other reason. The worker's rebases and restacks push through here, and
+ * so does `push-fixed-pr`, which a session runs.
+ */
+export declare const pushLeased: (branch: string, sha: string, lease: string, cwd?: string) => Promise<Result<'moved' | 'pushed', string>>;
+/**
+ * Brings one pull request as close to merging as this script can: onto the
+ * tip of the base, with the layers stacked on it carried along, armed, and
+ * out from under `skip-ci`.
+ *
+ * The order is the point. While `skip-ci` is on, the push the rebase makes
+ * fires a `synchronize` whose every check workflow skips, so it costs
+ * nothing; removing the label afterwards fires `unlabeled`, and the matrix
+ * that starts then runs once, on the head that will actually be merged. Doing
+ * it the other way round starts a full matrix on the pre-rebase head and has
+ * the push cancel it through the concurrency group. Arming comes between
+ * the two, so that while it happens the label still holds the merge.
+ *
+ * A pull request GitHub moved off a stack is rebased with `--onto` from the
+ * head its merged parent was merged at, when it still contains that head —
+ * GitHub's own rebase on retargeting can fail, and then the branch still
+ * carries the parent's commits, whose patches match the squash commit only
+ * if nothing changed them on the way in. Otherwise the plain rebase drops
+ * them by patch, as it always has.
+ *
+ * A rebase that changes nothing is a failure only when there was no label to
+ * take off either: then GitHub's `BEHIND` or `DIRTY` was stale and the survey
+ * has to start over. A paused pull request that is already on top of the base
+ * is simply one whose only obstacle was the label.
+ *
+ * A branch that moves while this is moving it is someone else moving the same
+ * pull request — the skill runs beside this script, and a person may push —
+ * so it resolves to `moved` and leaves the rest to that someone. Recording it
+ * as a failure would set a pull request aside for being worked on, and trying
+ * the next candidate would start a second matrix beside the one the other
+ * writer is about to start.
+ *
+ * The version pull request is the exception: only the label comes off it.
+ * `changesets/action` rebuilds that branch from the tip of the base itself
+ * and force-pushes the result, so rebasing it here would be a second thing
+ * force-pushing one branch — and would carry the old version commit onto a
+ * tip whose changesets it never consumed. Triage has already established
+ * that the branch is on the tip; there is nothing left to move.
+ */
+export declare const advance: (api: ApiContext, pr: PullRequest, defaultBranch: string, plan: AdvancePlan) => Promise<Result<Advanced, RebaseFailure>>;
+/**
+ * Rebases every pull request GitHub moved onto the default branch when the
+ * layer below it merged, and that still carries that layer's commits, off
+ * them: `--onto` from the head the layer merged at to the squash commit it
+ * merged as, carrying the layers stacked on it along. `stack.mts` says why
+ * this waits for no queue, and why the tree comes out as it went in.
+ *
+ * Nothing is armed or released: `skip-ci` stays as it is, and a push under
+ * it fires a `synchronize` whose every check skips. Resolves to whether any
+ * branch moved — by this, or by someone else under it — since either makes
+ * the heads the survey read stale.
+ */
+export declare const restackRetargeted: (api: ApiContext, before: StackedOn | undefined, pullRequests: readonly PullRequest[], defaultBranch: string, dryRun: boolean) => Promise<boolean>;
+/**
+ * Rebases the pull requests that asked for it and are paused by `skip-ci`
+ * and behind the default branch onto it, carrying the layers stacked on each
+ * along, so that a stack waiting for review or for its turn keeps a diff of
+ * its own changes only. The push runs no checks: the label skips every workflow.
+ * `stack.mts` says which pull requests are eligible.
+ *
+ * A rebase that conflicts, or a push that is refused, is a set-aside like any
+ * other and is returned as one, tied to the head and the base it was tried at.
+ * Resolves to those records and whether any branch moved — by this, or by
+ * someone else under it — since either makes the survey stale.
+ */
+export declare const restackBehind: (pullRequests: readonly PullRequest[], defaultBranch: string, context: Readonly<{
+    baseSha: string;
+    skipped: SkipRecords;
+    owners: ReadonlyMap<number, QueueOwner>;
+    dryRun: boolean;
+}>) => Promise<Readonly<{
+    skipped: SkipRecords;
+    moved: boolean;
+}>>;
+/**
+ * Carries every layer stacked on `pr` along after it moved from its old head
+ * to `head`: each is replayed with `--onto` from the head it was on to the
+ * one that replaced it, lowest layer first so that each finds its own new
+ * base already pushed. A layer that cannot be moved, or that someone else
+ * moved first, is reported and left where it is, and so is everything on
+ * it; none of this stops `pr` itself, whose turn it is. `push-fixed-pr`
+ * carries a session's layers along through here too.
+ */
+export declare const restack: (pr: BranchOf, head: string, descendants: readonly BranchOf[]) => Promise<void>;
+/**
+ * Arms auto-merge on the pull request this cycle picked, having first asked
+ * whether it is still what triage saw: open, on the default branch, queued,
+ * at `head`. A head other than that is someone else moving it, as in
+ * `removeSkipCiLabel`.
+ *
+ * Called for one it rebases after the push and before `skip-ci` comes off, so
+ * that the label holds the merge until the matrix that decides it starts; and
+ * for one already up to date before it is watched.
+ *
+ * Nothing else arms one. `open-pr` opens a pull request with none, and the
+ * author queueing it with `merge-queued` is the request to land it. Arming at
+ * pick time rather than at opening is what keeps a stacked pull request
+ * unarmed while it is stacked: its base is another pull request's branch,
+ * which no ruleset covers, so armed there it would merge into that branch
+ * the moment nothing held it. It is picked only once GitHub has moved it onto
+ * the default branch, where the ruleset gates the merge.
+ *
+ * `merge-queued` is the only thing read as permission, so one that has lost
+ * its auto-merge — GitHub disarms it when the base changes, and a person may
+ * switch it off — is armed again when it is next picked. Holding one back is
+ * taking `merge-queued` off.
+ */
+export declare const armOnPick: (api: ApiContext, pr: PullRequest, head: string, defaultBranch: string) => Promise<Result<'armed' | 'moved', RebaseFailure>>;
+//# sourceMappingURL=rebase.d.mts.map

package/dist/unblock-prs/rebase.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebase.d.mts","sourceRoot":"","sources":["../../src/unblock-prs/rebase.mts"],"names":[],"mappings":"AAUA,OAAO,EAKL,KAAK,UAAU,EAChB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAiB,MAAM,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAA6B,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAuB9E,OAAO,KAAK,EACV,QAAQ,EACR,WAAW,EACX,QAAQ,EACR,WAAW,EACX,aAAa,EAEb,WAAW,EACX,SAAS,EACV,MAAM,aAAa,CAAC;AAiMrB;;;;;GAKG;AACH,eAAO,MAAM,UAAU,WACb,MAAM,OACT,MAAM,SACJ,MAAM,QACP,MAAM,KACX,OAAO,CAAC,MAAM,CAAC,OAAO,GAAG,QAAQ,EAAE,MAAM,CAAC,CAoB5C,CAAC;AAIF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,OAAO,QACb,UAAU,MACX,WAAW,iBACA,MAAM,QACf,WAAW,KAChB,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,aAAa,CAAC,CA8EzC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,QACvB,UAAU,UACP,SAAS,GAAG,SAAS,gBACf,SAAS,WAAW,EAAE,iBACrB,MAAM,UACb,OAAO,KACd,OAAO,CAAC,OAAO,CAqBjB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,iBACV,SAAS,WAAW,EAAE,iBACrB,MAAM,WACZ,QAAQ,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,WAAW,CAAC;IACrB,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACxC,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC,KACD,OAAO,CAAC,QAAQ,CAAC;IAAE,OAAO,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC,CAqG5D,CAAC;AAwPF;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,OACd,QAAQ,QACN,MAAM,eACC,SAAS,QAAQ,EAAE,KAC/B,OAAO,CAAC,IAAI,CAuDd,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,SAAS,QACf,UAAU,MACX,WAAW,QACT,MAAM,iBACG,MAAM,KACpB,OAAO,CAAC,MAAM,CAAC,OAAO,GAAG,OAAO,EAAE,aAAa,CAAC,CAkDlD,CAAC"}