@hearsay-tools/squawk 0.0.0-stage → 0.17.0-dev.5685

package/dist/server/forge/github.d.ts

@@ -0,0 +1,393 @@
+import type { RepoHandleDiscovery } from './repo-handle-discovery.ts';
+export type { RepoHandleDiscovery } from './repo-handle-discovery.ts';
+export { createDraftPr, buildPrBody } from './draft-pr.ts';
+import type { ArchivePullRequestIdentity, MergedPullRequest } from '../../contract/index.js';
+import { z } from 'zod';
+import { type GithubCommentCountsData, type GithubItemResponse, type GithubProjectsData } from '../../contract/index.js';
+export { normalizeMergeState } from './github-merge-state.ts';
+export { fetchTimelinePages, ghTimelineEventSchema, normalizeEvents, TIMELINE_BUDGET_MS, TIMELINE_EVENT_CAP, TIMELINE_EVENT_KINDS, TIMELINE_MAX_PAGES, TIMELINE_MIN_PAGE_MS, } from './github-timeline.ts';
+import type { ForgeAvailability, ForgeComment, ForgeCommentsData, ForgeDriver, ForgeItem, ForgeListOptions, ForgePrMergeState, ForgePrDiffResult, ForgeSearchData, ForgeTimelineEvent } from './types.ts';
+export declare const GH_PR_DIFF_FILE_CAP = 300;
+export declare const GH_PR_PATCH_CAP: number;
+export declare const GH_PR_DIFF_JSON_CAP: number;
+export declare class GithubPrNotFoundError extends Error {
+}
+export type PrFilesPageRunner = (page: number) => Promise<string>;
+/** Fetch no more than the three GitHub pages represented by the public 300-file response cap. */
+export declare function fetchPrFilePages(runPage: PrFilesPageRunner): Promise<unknown[]>;
+export declare function fetchGithubPrDiff(repoRoot: string, number: number, refresh?: boolean): Promise<ForgePrDiffResult>;
+/** One GitHub issue or pull request, flattened for the cockpit's GitHub tab. */
+export type GithubItem = ForgeItem;
+export type GithubData = import('../../contract/index.js').GithubData;
+export declare const ghCheckRunSchema: z.ZodObject<{
+    state: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    conclusion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+declare const ghStatusCheckRollup: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+    state: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    conclusion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>>>>;
+/** Exported for unit tests (#400) — collapses a zod-validated `statusCheckRollup` array down to
+ *  the single enum the GitHub tab (list rows + detail badge) renders. */
+export declare function rollupToChecks(rollup: z.infer<typeof ghStatusCheckRollup>): GithubItem['checks'];
+/** Runs a GraphQL query — injected so pagination is unit-testable without shelling to `gh`.
+ *  Number variables reach GitHub typed (`-F`), strings raw (`-f`): see `ghGraphqlArgs`. */
+export type GraphqlRunner = (query: string, variables: Record<string, string | number>) => Promise<string>;
+/** `gh api graphql` argv. `-f` sends every value as a String, and GitHub rejects a String where
+ *  the query declares `Int!` ("Could not coerce value to Int", open-mercato/cezar#1366), so a
+ *  number goes through `-F`. A string never does: `-F` would read `@file` and coerce
+ *  `true`/numerals, which is not what an opaque cursor or a login means. */
+export declare function ghGraphqlArgs(query: string, variables?: Record<string, string | number>): string[];
+/** `owner/name` → `{ owner, name }`, or null when the handle isn't a clean two-part slug. */
+export declare function parseOwnerName(nameWithOwner: string): {
+    owner: string;
+    name: string;
+} | null;
+/** GitHub GraphQL rejects `first` above 100 (EXCESSIVE_PAGINATION); larger limits walk pages. */
+export declare const GH_GRAPHQL_PAGE_MAX = 100;
+export type ListSide = 'issues' | 'pullRequests';
+declare const ghListNodeSchema: z.ZodObject<{
+    number: z.ZodNumber;
+    title: z.ZodString;
+    author: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        login: z.ZodString;
+    }, z.core.$strip>>>;
+    createdAt: z.ZodString;
+    url: z.ZodString;
+    body: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    labels: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        nodes: z.ZodDefault<z.ZodArray<z.ZodNullable<z.ZodObject<{
+            name: z.ZodString;
+            color: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>>;
+    }, z.core.$strip>>>, z.ZodTransform<{
+        name: string;
+        color: string;
+    }[], {
+        nodes: ({
+            name: string;
+            color: string;
+        } | null)[];
+    } | null | undefined>>;
+    assignees: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        nodes: z.ZodDefault<z.ZodArray<z.ZodNullable<z.ZodObject<{
+            login: z.ZodString;
+        }, z.core.$strip>>>>;
+    }, z.core.$strip>>>, z.ZodTransform<{
+        login: string;
+    }[], {
+        nodes: ({
+            login: string;
+        } | null)[];
+    } | null | undefined>>;
+    isDraft: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    additions: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    deletions: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export type ListNode = z.infer<typeof ghListNodeSchema>;
+/**
+ * One side of the open list: up to `limit` rows from `cursor`, in requests of at most
+ * `GH_GRAPHQL_PAGE_MAX`. `nextCursor` is where the rows stop, or `null` once the side is
+ * exhausted. `done` asks for `first: 0`, which still answers `totalCount`, so an exhausted side
+ * keeps a fresh total without ever restarting from its first page (open-mercato/cezar#1366
+ * restarted it while the other side paged).
+ */
+export declare function fetchListConnection(run: GraphqlRunner, owner: string, name: string, side: ListSide, limit: number, cursor?: string, done?: boolean): Promise<{
+    totalCount: number;
+    nodes: ListNode[];
+    nextCursor: string | null;
+}>;
+export declare const GH_MAX_LIMIT = 1000;
+/** Where one list page starts on each side. A done side answered `nextCursor: null` already. */
+export type GithubPageRequest = Pick<ForgeListOptions, 'issuesCursor' | 'prsCursor' | 'issuesDone' | 'prsDone'>;
+export declare function fetchGithub(repoRoot: string, refresh?: boolean, limit?: number, page?: GithubPageRequest): Promise<GithubData>;
+/** A `gh` failure as one readable line. GitHub's own words come on stderr; the Node message
+ *  starts with the whole argv, and a GraphQL argv is a multi-line query, so its first line is
+ *  a fragment of that query rather than the reason (open-mercato/cezar#1366). */
+export declare function ghFailureReason(err: unknown): string;
+/** Bounded lookup already started by the list. Never launch work for an expired generation. */
+export declare function fetchGithubProjects(repoRoot: string, generation: string): Promise<GithubProjectsData>;
+/** Hits per search. `gh search`'s own default is 30; 50 matches the page size the incremental-
+ *  loading spec settled on and keeps one search to a single `gh` round-trip. */
+export declare const GH_SEARCH_MAX = 50;
+/**
+ * One issue or PR by number, in any state (#692). `null` when `gh` confirms the item is absent;
+ * throws on every other failure. `labelColors` is an optional out-param.
+ */
+export declare function viewGithubItem(repoRoot: string, kind: 'issue' | 'pr', number: number, labelColors?: Record<string, string>): Promise<ForgeItem | null>;
+/**
+ * Search any state: exact numbers try a direct lookup, then text fallback; text search omits
+ * state restriction. Return availability and a reason on failure instead of throwing.
+ */
+export declare function searchGithubItems(repoRoot: string, kind: 'issue' | 'pr', query: string, limit?: number): Promise<ForgeSearchData>;
+/** First 200 thread entries, then `truncated`; each body sliced to 8 000 chars (same cap as
+ *  item bodies). */
+export declare const THREAD_ENTRY_CAP = 200;
+/** `gh api …/issues/{n}/comments` JSON → `ForgeComment[]`. Exported for unit tests. */
+export declare function normalizeComments(raw: unknown): ForgeComment[];
+/** `gh api …/pulls/{n}/reviews` JSON → `ForgeComment[]`. Reviews with an empty body AND state
+ *  COMMENTED/PENDING carry no signal in a flat thread and are dropped; the rest map to
+ *  `kind: 'review'` (Q4). Exported for unit tests. */
+export declare function normalizeReviews(raw: unknown): ForgeComment[];
+/** Merge comment/review lists chronologically (oldest first) and apply the entry cap. Exported
+ *  for unit tests. */
+export declare function mergeThread(parts: ForgeComment[][], cap?: number): {
+    comments: ForgeComment[];
+    truncated: boolean;
+};
+/** Test-only: drop the per-thread cache so cases don't leak state into each other. */
+export declare function __clearCommentsCacheForTests(): void;
+export declare function forgetGithubItem(repoRoot: string, kind: 'issue' | 'pr', number: number): void;
+/** Test-only: drop the single-item cache. */
+export declare function __clearGithubItemCacheForTests(): void;
+export declare function fetchGithubItem(repoRoot: string, kind: 'issue' | 'pr', number: number, refresh?: boolean): Promise<GithubItemResponse>;
+/** Test-only: drop the memoized repo handles. */
+export declare function __clearRepoHandleCacheForTests(): void;
+/** Share the existing memo with ordinary discovery, but retain failure classification (#102).
+ * An aborted owner must never publish its late result into this shared cache. */
+export declare function discoverRepoHandle(repoRoot: string, signal?: AbortSignal): Promise<RepoHandleDiscovery>;
+/** Compatible fail-open lookup for existing API and cold-index callers. */
+export declare function resolveRepoHandle(repoRoot: string, signal?: AbortSignal): Promise<{
+    owner: string;
+    name: string;
+} | null>;
+/** SHAs per rollup query. Aliases resolve independently, so a chunk that fails costs only its own
+ *  glyphs — but an unbounded alias list would eventually blow the query size limit. */
+export declare const COMMIT_CHECKS_CHUNK = 50;
+/**
+ * Rolled-up CI state per commit SHA, as a `sha → checks` map.
+ *
+ * Batched and aliased so a 40-commit PR costs one subprocess, not forty. Verified against the live
+ * API: each alias resolves independently and an unknown SHA comes back `null` rather than erroring
+ * the batch, so partial results degrade cleanly.
+ *
+ * Degrades to an empty map on any failure — exactly as `fetchCommentCounts` does for counts. The
+ * caller then leaves `checks` **absent**, which the UI renders as no glyph. Exported for tests;
+ * `runGraphql` is injected so this is testable without shelling out.
+ */
+export declare function fetchCommitChecks(runGraphql: GraphqlRunner, owner: string, name: string, shas: string[], chunkSize?: number): Promise<Record<string, ForgeTimelineEvent['checks']>>;
+/** The single enum a PR row's checks glyph renders (never `undefined` on the wire). */
+export type ChecksGlyph = 'passing' | 'failing' | 'pending' | null;
+export type GithubChecksData = {
+    available: true;
+    checks: Record<number, ChecksGlyph>;
+} | {
+    available: false;
+    reason: string;
+};
+/** PR numbers per checks query. Aliases resolve independently (a failed chunk costs only its own
+ *  glyphs); bounded so an unbounded number list can't blow the query size limit. Also the route's
+ *  hard cap on how many PRs one request may ask about. */
+export declare const GH_CHECKS_MAX = 100;
+/**
+ * Rolled-up CI state per PR number, as a `number → glyph` map.
+ *
+ * Batched and aliased so a 100-PR window costs one subprocess, not a hundred. Each alias resolves
+ * independently and an unknown number comes back `null` (alias resolved null → left absent), so
+ * partial results degrade cleanly. Degrades to an empty map on any failure — exactly as
+ * `fetchCommitChecks` does. Exported for tests; `runGraphql` is injected so this is testable
+ * without shelling out.
+ */
+export declare function fetchPrChecks(runGraphql: GraphqlRunner, owner: string, name: string, numbers: number[], chunkSize?: number): Promise<Record<number, ChecksGlyph>>;
+/**
+ * Comment counts for the given issue or PR numbers, in one aliased GraphQL query. A number GitHub
+ * does not know is absent (unknown), never 0. Degrades to `{ available: false, reason }` — never a
+ * throw. Numbers are de-duplicated, validated and capped at `GITHUB_COMMENT_COUNTS_MAX`.
+ */
+export declare function fetchGithubCommentCounts(repoRoot: string, kind: 'issue' | 'pr', numbers: number[], refresh?: boolean): Promise<GithubCommentCountsData>;
+/** Test hook — the per-PR checks cache would otherwise leak state across cases in one process. */
+export declare function __clearChecksCacheForTests(): void;
+/**
+ * Lazy checks glyphs for the given PR numbers (route-facing). Resolves the repo handle once,
+ * serves fresh cache entries, queries only the misses, and degrades to `{ available: false,
+ * reason }` when `gh` or the handle is unavailable — never a throw, never a 5xx (plan rule 7).
+ * Numbers are de-duplicated, validated, and capped at `GH_CHECKS_MAX`.
+ */
+export declare function fetchGithubChecks(repoRoot: string, numbers: number[]): Promise<GithubChecksData>;
+/** Where a referenced PR or issue stands. Mirrored by `referenceStatusSchema` in the contract —
+ *  see there for why PR `closed` and issue `completed` are separate words. */
+export type ReferenceStatus = 'draft' | 'review-required' | 'changes-requested' | 'checks-pending' | 'checks-failing' | 'ready' | 'merged' | 'closed' | 'open' | 'completed' | 'not-planned';
+export type GithubRefStatusData = {
+    available: true;
+    prs: Record<number, ReferenceStatus>;
+    issues: Record<number, ReferenceStatus>;
+    /** The OPEN pull requests among them that do not merge into their base — the second axis,
+     *  never folded into a status. Optional on the wire, and absent means "nothing is known"
+     *  rather than "no conflicts"; see `conflicts` in the contract. */
+    conflicts?: number[];
+    /** When to ask again, or `null` when nothing here can change. See `recheckAfterMs` in the
+     *  contract for why the SERVER answers this. */
+    recheckAfterMs: number | null;
+} | {
+    available: false;
+    reason: string;
+    recheckAfterMs: number | null;
+};
+/** Numbers per kind in one ref-status query — the same bound, and for the same reasons, as
+ *  `GH_CHECKS_MAX`: aliases resolve independently, and the query size stays finite. Taken from the
+ *  contract rather than restated, because the cockpit caps its batches by the same number and a
+ *  client that guessed high would have every chip in a batch 400 instead of losing its tail. */
+export declare const GH_REF_STATUS_MAX = 100;
+/**
+ * Derive whose action is pending: terminal, draft, pending checks, current requested changes,
+ * failing checks, review, then ready. Use dated review/work evidence; mergeability remains a
+ * separate axis.
+ */
+export declare function derivePrReferenceStatus(pr: {
+    state: string;
+    isDraft?: boolean | null | undefined;
+    reviewDecision?: string | null | undefined;
+    checks: ChecksGlyph;
+    /** ISO-8601 commit date of the head commit. `committedDate`, not a push time: GitHub's
+     *  `pushedDate` is deprecated and comes back null on new PRs. */
+    headCommittedAt?: string | null | undefined;
+    /** How many parents the head commit has. 2+ means a MERGE — "Update branch" pulling the base in,
+     *  not work on the review. See `answered` below. Absent reads as an ordinary commit: the push
+     *  rule is the common path and must not switch off on a field GitHub declined to send. */
+    headParentCount?: number | null | undefined;
+    /** ISO-8601 `committedDate` of the head's FIRST parent, which on a merge is the branch's previous
+     *  tip — the newest commit that is actual work. Only read when the head is a merge. */
+    headFirstParentCommittedAt?: string | null | undefined;
+    /** ISO-8601 `submittedAt` of the most recent CHANGES_REQUESTED review, when there is one. */
+    changesRequestedAt?: string | null | undefined;
+    /** Is a reviewer currently ON THE HOOK — `reviewRequests.totalCount > 0`? True after the author
+     *  clicks re-request, which is the one thing that says so while `reviewDecision` still reads
+     *  `CHANGES_REQUESTED` — but also true of a reviewer asked long ago who never looked, hence
+     *  `reviewRequestedAt`. */
+    reviewRequested?: boolean | null;
+    /** ISO-8601 `createdAt` of the most recent `ReviewRequestedEvent`, which is WHEN the standing
+     *  request was made. Only a request younger than the review can be an answer to it. */
+    reviewRequestedAt?: string | null;
+}): ReferenceStatus;
+/**
+ * Whether this pull request's branch merges into its base — the OTHER axis, kept out of
+ * `derivePrReferenceStatus` on purpose (see `conflicts` in the contract).
+ *
+ * Three values, and the third is the one that matters. GitHub does not store mergeability; it
+ * COMPUTES it when asked, and answers `UNKNOWN` while the background job runs — which is the
+ * normal answer for the first seconds after every push, and therefore for exactly the moment a
+ * cockpit is most likely to be looking. `UNKNOWN` means *we were not told*, never *it is clean*,
+ * and the caller must be able to tell those apart: it is what decides how soon to ask again
+ * (`refStatusTtl`), and answering it as "not conflicting" with a one-minute TTL is precisely how a
+ * conflicting pull request came to sit there wearing "Ready to merge".
+ *
+ * `undefined` for anything the question does not apply to: an issue, and a merged or closed pull
+ * request (GitHub says `UNKNOWN` for those too, forever, and a terminal PR has no conflict left to
+ * resolve — a merged PR wearing a conflict chip is a lie the state alone rules out).
+ */
+export type Mergeability = 'mergeable' | 'conflicting' | 'unknown';
+export declare function mergeabilityOf(state: string, mergeable: string | null | undefined): Mergeability | undefined;
+/**
+ * An issue's two signals as one word. `NOT_PLANNED` is kept apart from `completed` because they
+ * are opposite outcomes — "we did it" vs "we won't" — and a task whose issue was declined must
+ * not read as a task that landed.
+ */
+export declare function deriveIssueReferenceStatus(issue: {
+    state: string;
+    stateReason?: string | null | undefined;
+}): ReferenceStatus;
+/** What one number turned out to be, and where it stands. `kind` is the forge's answer, not the
+ *  caller's guess — see `refStatusQuery`. */
+export interface ResolvedReference {
+    kind: 'pr' | 'issue';
+    status: ReferenceStatus;
+    /** Where this pull request stands on the OTHER axis, or absent when the question does not
+     *  apply (an issue, a merged or closed PR). Deliberately not folded into `status`; see
+     *  `mergeabilityOf`, and `conflicts` in the contract. `unknown` is kept as a value rather than
+     *  collapsed into "not conflicting", because it is the difference between an answer and a
+     *  question GitHub has not finished answering. */
+    mergeable?: Mergeability;
+}
+/**
+ * The outcome of one batched lookup. `failed` is what separates *this number is not in the
+ * repository* from *we could not ask about this number* — an absence and a failure, which look
+ * identical in a `number → status` map and mean opposite things to a reader ("that reference is
+ * bogus" vs "GitHub is down"). Keeping them apart is what stops a transient error being cached,
+ * and shown, as "not found".
+ */
+export interface RefStatusBatch {
+    resolved: Record<number, ResolvedReference>;
+    /** Numbers whose chunk threw. Nothing is known about them either way. */
+    failed: number[];
+    /** First failure's message, for the payload's `reason`. */
+    reason?: string;
+}
+/**
+ * Status per NUMBER, resolved to whatever that number actually is.
+ *
+ * Batched and aliased like `fetchPrChecks`: one subprocess per chunk, each alias resolving
+ * independently, and a number the forge does not have simply staying absent from `resolved` (its
+ * chip then renders neutral, as it did before this seam existed). A failed chunk costs only its
+ * own numbers, and says so rather than letting them look absent. Exported for tests; `runGraphql`
+ * is injected so this is testable without shelling out.
+ */
+export declare function fetchRefStatuses(runGraphql: GraphqlRunner, owner: string, name: string, numbers: number[], chunkSize?: number): Promise<RefStatusBatch>;
+/** Test-only: drop the per-reference cache so cases don't leak state into each other. */
+export declare function __clearRefStatusCacheForTests(): void;
+/** Test-only: warm the cache the way the lazy route would have, so a reader can be tested
+ *  without a forge behind it. */
+export declare function __seedRefStatusCacheForTests(repoRoot: string, entries: Array<[number, ResolvedReference]>): void;
+/**
+ * Invalidate one reference after a known mutation. Let the next forge read establish status
+ * rather than caching a guessed result.
+ */
+export declare function forgetRefStatus(repoRoot: string, number: number): void;
+/**
+ * Everything the cache ALREADY knows about these numbers. Never spawns `gh`, never awaits.
+ *
+ * This is what lets a status ride along with the rows that carry the references, instead of the
+ * cockpit fetching it separately a moment later: the run index reads whatever is warm and ships
+ * it, and a cold entry is simply absent — the lazy `/github/ref-status` route stays the thing that
+ * actually goes and asks.
+ *
+ * Because it cannot cost anything, the caller may pass a SUPERSET of the numbers it will really
+ * display. That matters: deciding which of a run's references a chip shows is the cockpit's rule
+ * (#407, #526), deliberately not duplicated server-side, and a cache read does not need to know —
+ * it can look up every number a run mentions and let the client pick.
+ */
+export declare function readCachedRefStatuses(repoRoot: string, numbers: Iterable<number>): {
+    prs: Record<number, ReferenceStatus>;
+    issues: Record<number, ReferenceStatus>;
+};
+export { refNumberFromUrl } from '../../contract/index.js';
+/**
+ * Route-facing reference status. Resolves the repo handle once, serves fresh cache entries,
+ * queries only the misses, and degrades to `{ available: false, reason }` when `gh` or the handle
+ * is unavailable — never a throw, never a 5xx.
+ *
+ * The two request lists are merged into ONE set of numbers: issues and pull requests share a
+ * repository's numbering space, so a number is one thing and asking about it twice would be asking
+ * the same question twice. What comes back is filed by what each number turned out to BE, which is
+ * why a chip whose kind the cockpit guessed wrong still gets the right status.
+ */
+export declare function fetchGithubRefStatus(repoRoot: string, input: {
+    prs?: number[];
+    issues?: number[];
+}): Promise<GithubRefStatusData>;
+export declare function fetchGithubComments(repoRoot: string, kind: 'issue' | 'pr', number: number, refresh?: boolean): Promise<ForgeCommentsData>;
+/**
+ * Non-blocking availability for `GET /api/health` (#major-health-latency): serves the last-known
+ * probe immediately (stale-while-revalidate) and only returns `null` on a cold start, before the
+ * first probe has ever warmed the cache. It NEVER shells out to `gh` on the request that reads it,
+ * so health stays under the bookmarklet's 800 ms port budget (a `gh repo view` round-trip is
+ * ~500–650 ms on its own). `null` is contract-safe — the whole `forge` field is additive, so
+ * "unknown until warm" is a valid answer.
+ *
+ * Serving the stale value while revalidating is what keeps the GitHub nav item from flickering:
+ * without it, every time the 60 s cache expired this returned `null` for one 5 s health poll,
+ * dropping `forge.available` and blinking the sidebar item out until the background probe warmed.
+ */
+export declare function detectGithubCached(repoRoot: string): ForgeAvailability | null;
+export declare function evictGithubProjectCaches(repoRoot: string): void;
+export declare function mergePreflightAllowed(current: ForgePrMergeState, overrideRules?: boolean): boolean;
+/** owner/repo parsed out of the origin remote — feeds `viewUrl`. */
+export interface GithubRepoRef {
+    owner: string;
+    repo: string;
+}
+export declare function createGithubDriver(repoRoot: string, repoRef: GithubRepoRef | null): ForgeDriver;
+/** Strict archive authority: no partial GraphQL success, redirects, guessed identity or date. */
+export declare function fetchMergedPullRequests(runGraphql: GraphqlRunner, identities: readonly ArchivePullRequestIdentity[]): Promise<MergedPullRequest[]>;
+export declare function lookupMergedPullRequests(repoRoot: string, identities: ArchivePullRequestIdentity[], signal: AbortSignal): Promise<MergedPullRequest[]>;