pr-shepherd 0.34.0 → 0.36.0

package/bin/github/batch-parsers-rules.mjs

@@ -0,0 +1,122 @@
+export const EMPTY_BRANCH_RULES = {
+    requiredApprovingReviewCount: 0,
+    requiresConversationResolution: false,
+    requiresCodeOwnerReviews: false,
+    requiresLastPushApproval: false,
+    requiresCommitSignatures: false,
+    requiresLinearHistory: false,
+    requiresStrictStatusChecks: false,
+    requiredStatusCheckContexts: [],
+    requiredDeploymentEnvironments: [],
+    requiresMergeQueue: false,
+    requiresWorkflows: false,
+    requiresCodeScanning: false,
+};
+export function parseBranchRules(baseRef) {
+    const rules = {
+        ...EMPTY_BRANCH_RULES,
+        requiredStatusCheckContexts: [],
+        requiredDeploymentEnvironments: [],
+    };
+    if (!baseRef)
+        return rules;
+    foldClassicProtection(rules, baseRef.branchProtectionRule);
+    for (const node of baseRef.rules?.nodes ?? [])
+        foldRulesetRule(rules, node);
+    return rules;
+}
+export function parseMergeQueueEntry(raw) {
+    if (!raw)
+        return null;
+    return {
+        position: raw.position,
+        state: raw.state,
+        estimatedTimeToMerge: raw.estimatedTimeToMerge,
+    };
+}
+export function parseStack(raw) {
+    if (!raw.stack)
+        return null;
+    return {
+        number: raw.stack.number,
+        size: raw.stack.size,
+        position: raw.stackEntry?.position ?? 0,
+        baseRefName: raw.stack.baseRefName,
+    };
+}
+function foldClassicProtection(rules, bp) {
+    if (!bp)
+        return;
+    if (bp.requiresApprovingReviews) {
+        rules.requiredApprovingReviewCount = Math.max(rules.requiredApprovingReviewCount, bp.requiredApprovingReviewCount ?? 0);
+    }
+    if (bp.requiresConversationResolution)
+        rules.requiresConversationResolution = true;
+    if (bp.requiresCodeOwnerReviews)
+        rules.requiresCodeOwnerReviews = true;
+    if (bp.requireLastPushApproval)
+        rules.requiresLastPushApproval = true;
+    if (bp.requiresCommitSignatures)
+        rules.requiresCommitSignatures = true;
+    if (bp.requiresLinearHistory)
+        rules.requiresLinearHistory = true;
+    if (bp.requiresStrictStatusChecks)
+        rules.requiresStrictStatusChecks = true;
+    if (bp.requiresStatusChecks) {
+        mergeUnique(rules.requiredStatusCheckContexts, bp.requiredStatusCheckContexts ?? []);
+    }
+    if (bp.requiresDeployments) {
+        mergeUnique(rules.requiredDeploymentEnvironments, bp.requiredDeploymentEnvironments ?? []);
+    }
+}
+function foldRulesetRule(rules, node) {
+    const p = node.parameters;
+    switch (node.type) {
+        case "PULL_REQUEST":
+            if (p?.requiredApprovingReviewCount != null) {
+                rules.requiredApprovingReviewCount = Math.max(rules.requiredApprovingReviewCount, p.requiredApprovingReviewCount);
+            }
+            if (p?.requiredReviewThreadResolution)
+                rules.requiresConversationResolution = true;
+            if (p?.requireCodeOwnerReview)
+                rules.requiresCodeOwnerReviews = true;
+            if (p?.requireLastPushApproval)
+                rules.requiresLastPushApproval = true;
+            break;
+        case "REQUIRED_REVIEW_THREAD_RESOLUTION":
+            rules.requiresConversationResolution = true;
+            break;
+        case "REQUIRED_STATUS_CHECKS":
+            if (p?.strictRequiredStatusChecksPolicy)
+                rules.requiresStrictStatusChecks = true;
+            mergeUnique(rules.requiredStatusCheckContexts, (p?.requiredStatusChecks ?? []).map((c) => c.context));
+            break;
+        case "REQUIRED_SIGNATURES":
+            rules.requiresCommitSignatures = true;
+            break;
+        case "REQUIRED_LINEAR_HISTORY":
+            rules.requiresLinearHistory = true;
+            break;
+        case "REQUIRED_DEPLOYMENTS":
+            mergeUnique(rules.requiredDeploymentEnvironments, p?.requiredDeploymentEnvironments ?? []);
+            break;
+        case "MERGE_QUEUE":
+            rules.requiresMergeQueue = true;
+            break;
+        case "WORKFLOWS":
+        case "REQUIRED_WORKFLOW_STATUS_CHECKS":
+            rules.requiresWorkflows = true;
+            break;
+        case "CODE_SCANNING":
+            rules.requiresCodeScanning = true;
+            break;
+        default:
+            break;
+    }
+}
+function mergeUnique(target, values) {
+    for (const value of values) {
+        if (value && !target.includes(value))
+            target.push(value);
+    }
+}

package/bin/github/batch-parsers.d.mts

@@ -0,0 +1,3 @@
+import type { BatchPrData } from "../types.mts";
+import type { RawPr, RawThread, RawComment, RawReview, RawReviewSummary, RawContextNode } from "./batch-raw-types.mts";
+export declare function parseRawPr(raw: RawPr, rawThreadPages: RawThread[], rawCommentNodes: RawComment[], rawReviewNodes: RawReview[], rawReviewSummaryNodes: RawReviewSummary[], rawApprovedReviewNodes: RawReviewSummary[], rawCheckNodes: RawContextNode[]): BatchPrData;

package/bin/github/batch-parsers.mjs

@@ -1,11 +1,13 @@
 import { mapAuthorType, parseCreatedAt, mapStatusContextState, latestApprovedLogins, isReviewStale, mapCheckRunNode, } from "./batch-parser-helpers.mjs";
 import { buildPrActivitySummary } from "./activity.mjs";
 import { parseBranchProtection } from "./branch-protection.mjs";
+import { parseBranchRules, parseMergeQueueEntry, parseStack } from "./batch-parsers-rules.mjs";
 function parseReviewNode(r) {
     const base = {
         id: r.id,
         author: r.author?.login ?? "unknown",
         authorType: mapAuthorType(r.author?.__typename, r.author?.login),
+        ...(r.authorAssociation !== undefined && { authorAssociation: r.authorAssociation }),
         body: r.body,
         createdAtUnix: r.createdAt ? parseCreatedAt(r.createdAt) : 0,
     };
@@ -32,6 +34,7 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
             ...(c.pullRequestReview?.id ? { reviewId: c.pullRequestReview.id } : undefined),
             author: c.author?.login ?? "unknown",
             authorType: mapAuthorType(c.author?.__typename, c.author?.login),
+            ...(c.authorAssociation !== undefined && { authorAssociation: c.authorAssociation }),
             body: c.body,
             url: c.url,
             createdAtUnix: c.createdAt ? parseCreatedAt(c.createdAt) : 0,
@@ -47,6 +50,9 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
             ...(comment?.pullRequestReview?.id ? { reviewId: comment.pullRequestReview.id } : undefined),
             author: comment?.author?.login ?? "unknown",
             authorType: mapAuthorType(comment?.author?.__typename, comment?.author?.login),
+            ...(comment?.authorAssociation !== undefined && {
+                authorAssociation: comment.authorAssociation,
+            }),
             body: comment?.body ?? "",
             url: comment?.url ?? "",
             createdAtUnix: comment?.createdAt ? parseCreatedAt(comment.createdAt) : 0,
@@ -58,6 +64,7 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
         isMinimized: c.isMinimized,
         author: c.author?.login ?? "unknown",
         authorType: mapAuthorType(c.author?.__typename, c.author?.login),
+        ...(c.authorAssociation !== undefined && { authorAssociation: c.authorAssociation }),
         body: c.body,
         url: c.url,
         createdAtUnix: c.createdAt ? parseCreatedAt(c.createdAt) : 0,
@@ -124,6 +131,11 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
         approvedReviews,
         checks,
         branchProtection: parseBranchProtection(raw),
+        branchRules: parseBranchRules(raw.baseRef),
+        isInMergeQueue: raw.isInMergeQueue ?? false,
+        isMergeQueueEnabled: raw.isMergeQueueEnabled ?? false,
+        mergeQueueEntry: parseMergeQueueEntry(raw.mergeQueueEntry),
+        stack: parseStack(raw),
         activity: buildPrActivitySummary(raw, comments, reviewThreads, reviewSummaries, allChangesRequestedReviews, approvedReviews),
     };
 }

package/bin/github/batch-raw-rules.d.mts

@@ -0,0 +1,59 @@
+export interface RawBranchProtectionRule {
+    requiresApprovingReviews: boolean;
+    requiredApprovingReviewCount: number;
+    requiresConversationResolution: boolean;
+    requiresStatusChecks: boolean;
+    requiredStatusCheckContexts: string[] | null;
+    requiresCodeOwnerReviews?: boolean;
+    requireLastPushApproval?: boolean;
+    requiresCommitSignatures?: boolean;
+    requiresLinearHistory?: boolean;
+    requiresStrictStatusChecks?: boolean;
+    requiresDeployments?: boolean;
+    requiredDeploymentEnvironments?: string[] | null;
+}
+interface RawMergeQueueEntry {
+    position: number;
+    state: string;
+    estimatedTimeToMerge: number | null;
+}
+interface RawStack {
+    number: number;
+    size: number;
+    baseRefName: string;
+}
+export interface RawRepositoryRule {
+    type: string;
+    parameters: RawRuleParameters | null;
+}
+interface RawRuleParameters {
+    requiredApprovingReviewCount?: number;
+    requiredReviewThreadResolution?: boolean;
+    requireCodeOwnerReview?: boolean;
+    requireLastPushApproval?: boolean;
+    strictRequiredStatusChecksPolicy?: boolean;
+    requiredStatusChecks?: Array<{
+        context: string;
+    }>;
+    requiredDeploymentEnvironments?: string[];
+    codeScanningTools?: Array<{
+        tool: string;
+    }>;
+}
+export interface RawBaseRef {
+    branchProtectionRule: RawBranchProtectionRule | null;
+    rules: {
+        nodes: RawRepositoryRule[];
+    } | null;
+}
+export interface RawPrMergeFields {
+    isInMergeQueue?: boolean;
+    isMergeQueueEnabled?: boolean;
+    mergeQueueEntry?: RawMergeQueueEntry | null;
+    stack?: RawStack | null;
+    stackEntry?: {
+        position: number;
+    } | null;
+    baseRef?: RawBaseRef | null;
+}
+export {};

package/bin/github/batch-raw-rules.mjs

@@ -0,0 +1 @@
+export {};

package/bin/github/batch-raw-types.d.mts

@@ -0,0 +1,216 @@
+import type { CommentAuthorAssociation } from "../types/github.mts";
+import type { RawPrMergeFields } from "./batch-raw-rules.mts";
+export interface RawBatchResponse {
+    repository: {
+        pullRequest: RawPr | null;
+    } | null;
+}
+export interface RawPr extends RawPrMergeFields {
+    id: string;
+    number: number;
+    state: string;
+    isDraft: boolean;
+    mergeable: string;
+    mergeStateStatus: string;
+    reviewDecision: string | null;
+    headRefOid: string;
+    headRefName: string;
+    headRepository: {
+        nameWithOwner: string;
+    } | null;
+    baseRefName: string;
+    baseRef: import("./batch-raw-rules.mts").RawBaseRef | null;
+    reviewRequests: {
+        nodes: Array<{
+            requestedReviewer: {
+                login?: string;
+                name?: string;
+            } | null;
+        }>;
+    };
+    latestReviews: {
+        nodes: Array<{
+            author: RawAuthor | null;
+            state: string;
+        }>;
+    };
+    reviewThreads: {
+        pageInfo: {
+            hasPreviousPage: boolean;
+            startCursor: string | null;
+        };
+        nodes: RawThread[];
+    };
+    comments: {
+        pageInfo: {
+            hasPreviousPage: boolean;
+            startCursor: string | null;
+        };
+        nodes: RawComment[];
+    };
+    changesRequestedReviews: {
+        pageInfo: {
+            hasPreviousPage: boolean;
+            startCursor: string | null;
+        };
+        nodes: RawReview[];
+    };
+    reviewSummaries: {
+        pageInfo: {
+            hasPreviousPage: boolean;
+            startCursor: string | null;
+        };
+        nodes: RawReviewSummary[];
+    };
+    allReviews?: {
+        totalCount: number;
+    };
+    approvedReviews: {
+        pageInfo: {
+            hasPreviousPage: boolean;
+            startCursor: string | null;
+        };
+        nodes: RawReviewSummary[];
+    };
+    commits: {
+        totalCount?: number;
+        nodes: Array<{
+            commit: {
+                oid: string;
+                committedDate?: string;
+                checkSuites?: RawCheckSuites;
+                statusCheckRollup: {
+                    contexts: {
+                        pageInfo: {
+                            hasNextPage: boolean;
+                            endCursor: string | null;
+                        };
+                        nodes: Array<RawContextNode | null>;
+                    };
+                } | null;
+            };
+        }>;
+    };
+}
+interface RawCheckSuites {
+    pageInfo: {
+        hasNextPage: boolean;
+    };
+    nodes: Array<{
+        conclusion: string | null;
+        workflowRun: {
+            databaseId: number | null;
+            event: string | null;
+            url: string | null;
+            workflow: {
+                name: string | null;
+            } | null;
+        } | null;
+    }>;
+}
+interface RawAuthor {
+    __typename?: string;
+    login: string;
+}
+export interface RawThreadComment {
+    id: string;
+    isMinimized: boolean;
+    url: string;
+    authorAssociation?: CommentAuthorAssociation;
+    author: RawAuthor | null;
+    pullRequestReview?: {
+        id: string;
+    } | null;
+    body: string;
+    path: string | null;
+    line: number | null;
+    startLine: number | null;
+    createdAt?: string;
+}
+export interface RawThread {
+    id: string;
+    isResolved: boolean;
+    isOutdated: boolean;
+    path?: string | null;
+    line?: number | null;
+    startLine?: number | null;
+    comments: {
+        pageInfo?: {
+            hasNextPage: boolean;
+            endCursor: string | null;
+        };
+        nodes: RawThreadComment[];
+    };
+}
+export interface RawReviewThreadCommentsResponse {
+    node: {
+        __typename?: string;
+        comments: {
+            pageInfo: {
+                hasNextPage: boolean;
+                endCursor: string | null;
+            };
+            nodes: RawThreadComment[];
+        } | null;
+    } | null;
+}
+export interface RawComment {
+    id: string;
+    isMinimized: boolean;
+    url: string;
+    authorAssociation?: CommentAuthorAssociation;
+    author: RawAuthor | null;
+    body: string;
+    createdAt?: string;
+}
+export interface RawReview {
+    id: string;
+    authorAssociation?: CommentAuthorAssociation;
+    author: RawAuthor | null;
+    body: string;
+    createdAt?: string;
+    commit?: {
+        oid: string;
+    };
+}
+export interface RawReviewSummary {
+    id: string;
+    isMinimized: boolean;
+    authorAssociation?: CommentAuthorAssociation;
+    author: RawAuthor | null;
+    body: string;
+    createdAt?: string;
+}
+export type RawContextNode = {
+    __typename: "CheckRun";
+    id: string;
+    name: string;
+    status: string;
+    conclusion: string | null;
+    detailsUrl: string | null;
+    completedAt?: string | null;
+    startedAt?: string | null;
+    title: string | null;
+    summary: string | null;
+    checkSuite: {
+        createdAt?: string;
+        updatedAt?: string;
+        workflowRun: {
+            event: string;
+            createdAt?: string;
+            updatedAt?: string;
+            workflow?: {
+                name: string;
+                databaseId?: number | null;
+            } | null;
+        } | null;
+    } | null;
+} | {
+    __typename: "StatusContext";
+    context: string;
+    state: string;
+    createdAt?: string;
+    targetUrl: string | null;
+    description: string | null;
+};
+export {};

package/bin/github/batch-response.d.mts

@@ -0,0 +1,4 @@
+import type { RepoInfo } from "./client.mts";
+import type { RawBatchResponse, RawContextNode, RawPr } from "./batch-raw-types.mts";
+export declare function requireRawPr(response: RawBatchResponse | null | undefined, pr: number, repo: RepoInfo): RawPr;
+export declare function requireContextNodes(nodes: Array<RawContextNode | null>): RawContextNode[];

package/bin/github/batch.d.mts

@@ -0,0 +1,24 @@
+import { type RateLimitInfo, type RepoInfo } from "./client.mts";
+import type { BatchPrData } from "../types.mts";
+interface BatchResult {
+    data: BatchPrData;
+    rateLimit?: RateLimitInfo;
+    /** True when GraphQL returned a complete CheckSuite page; skip REST startup-failure fetch. */
+    checkSuitesComplete?: boolean;
+}
+interface FetchPrBatchOptions {
+    /**
+     * When false (default), the first-page approvedReviews are returned but
+     * backward pagination is skipped. Iterate's approvals-minimize flow sets this
+     * to true only when the user opts in, so long-lived PRs with > 50 approvals
+     * don't pay extra GraphQL round-trips per iterate call for data no consumer
+     * currently uses. The first page is free — already inside the one batch
+     * request — so there's no need to conditionally omit the field itself.
+     */
+    paginateApprovedReviews?: boolean;
+}
+/**
+ * Fetch all PR data needed for a `shepherd check` in one (or a few, if paginating) GraphQL requests.
+ */
+export declare function fetchPrBatch(pr: number, repo: RepoInfo, opts?: FetchPrBatchOptions): Promise<BatchResult>;
+export {};

package/bin/github/batch.mjs

@@ -1,134 +1,28 @@
-import { graphql, graphqlWithRateLimit } from "./client.mjs";
-import { paginateForward, paginateBackward } from "./pagination.mjs";
+import { graphqlWithRateLimit } from "./client.mjs";
 import { hydrateThreadCommentPages } from "./thread-comments.mjs";
 import { BATCH_PR_QUERY } from "./queries.mjs";
 import { parseRawPr } from "./batch-parsers.mjs";
-import { requireContextNodes, requireRawPr } from "./batch-response.mjs";
+import { parseCheckSuitesComplete, parseSuiteStartupFailures } from "./batch-parse-suites.mjs";
+import { mergeStartupFailureChecks } from "../checks/startup-failures.mjs";
+import { paginateBatchConnections } from "./batch-page.mjs";
+import { requireRawPr } from "./batch-response.mjs";
 /**
  * Fetch all PR data needed for a `shepherd check` in one (or a few, if paginating) GraphQL requests.
  */
 export async function fetchPrBatch(pr, repo, opts = {}) {
-    // First page: no cursor variables.
     const result = await graphqlWithRateLimit(BATCH_PR_QUERY, {
         owner: repo.owner,
         repo: repo.name,
         pr,
     });
     const raw = requireRawPr(result.data, pr, repo);
-    // Paginate reviewThreads backward if the first page is incomplete.
-    let rawThreadPages = raw.reviewThreads.nodes;
-    if (raw.reviewThreads.pageInfo.hasPreviousPage && raw.reviewThreads.pageInfo.startCursor) {
-        // Pass startCursor so paginateBackward fetches pages *before* the already-
-        // fetched first page instead of re-fetching it from the start.
-        const extra = await paginateBackward(async (cursor) => {
-            const res = await graphql(BATCH_PR_QUERY, {
-                owner: repo.owner,
-                repo: repo.name,
-                pr,
-                ...(cursor ? { threadsCursor: cursor } : {}),
-            });
-            const pr2 = requireRawPr(res.data, pr, repo);
-            return pr2.reviewThreads;
-        }, raw.reviewThreads.pageInfo.startCursor);
-        // extra contains pages before the first page.
-        rawThreadPages = [...extra, ...rawThreadPages];
-    }
-    rawThreadPages = await hydrateThreadCommentPages(rawThreadPages);
-    // Paginate comments backward if the first page is incomplete.
-    let rawCommentNodes = raw.comments.nodes;
-    if (raw.comments.pageInfo.hasPreviousPage && raw.comments.pageInfo.startCursor) {
-        const extra = await paginateBackward(async (cursor) => {
-            const res = await graphql(BATCH_PR_QUERY, {
-                owner: repo.owner,
-                repo: repo.name,
-                pr,
-                ...(cursor ? { commentsCursor: cursor } : {}),
-            });
-            const pr2 = requireRawPr(res.data, pr, repo);
-            return pr2.comments;
-        }, raw.comments.pageInfo.startCursor);
-        rawCommentNodes = [...extra, ...rawCommentNodes];
-    }
-    // Paginate CHANGES_REQUESTED reviews backward if the first page is incomplete.
-    let rawReviewNodes = raw.changesRequestedReviews.nodes;
-    if (raw.changesRequestedReviews.pageInfo.hasPreviousPage &&
-        raw.changesRequestedReviews.pageInfo.startCursor) {
-        const extra = await paginateBackward(async (cursor) => {
-            const res = await graphql(BATCH_PR_QUERY, {
-                owner: repo.owner,
-                repo: repo.name,
-                pr,
-                ...(cursor ? { changesRequestedCursor: cursor } : {}),
-            });
-            const pr2 = requireRawPr(res.data, pr, repo);
-            return pr2.changesRequestedReviews;
-        }, raw.changesRequestedReviews.pageInfo.startCursor);
-        rawReviewNodes = [...extra, ...rawReviewNodes];
-    }
-    // Paginate COMMENTED review summaries backward if the first page is incomplete.
-    let rawReviewSummaryNodes = raw.reviewSummaries.nodes;
-    if (raw.reviewSummaries.pageInfo.hasPreviousPage && raw.reviewSummaries.pageInfo.startCursor) {
-        const extra = await paginateBackward(async (cursor) => {
-            const res = await graphql(BATCH_PR_QUERY, {
-                owner: repo.owner,
-                repo: repo.name,
-                pr,
-                ...(cursor ? { reviewSummariesCursor: cursor } : {}),
-            });
-            const pr2 = requireRawPr(res.data, pr, repo);
-            return pr2.reviewSummaries;
-        }, raw.reviewSummaries.pageInfo.startCursor);
-        rawReviewSummaryNodes = [...extra, ...rawReviewSummaryNodes];
-    }
-    // Paginate APPROVED reviews backward if the first page is incomplete — gated behind
-    // `paginateApprovedReviews` because approvals minimization is opt-in. See FetchPrBatchOptions.
-    let rawApprovedReviewNodes = raw.approvedReviews.nodes;
-    if (opts.paginateApprovedReviews &&
-        raw.approvedReviews.pageInfo.hasPreviousPage &&
-        raw.approvedReviews.pageInfo.startCursor) {
-        const extra = await paginateBackward(async (cursor) => {
-            const res = await graphql(BATCH_PR_QUERY, {
-                owner: repo.owner,
-                repo: repo.name,
-                pr,
-                ...(cursor ? { approvedReviewsCursor: cursor } : {}),
-            });
-            const pr2 = requireRawPr(res.data, pr, repo);
-            return pr2.approvedReviews;
-        }, raw.approvedReviews.pageInfo.startCursor);
-        rawApprovedReviewNodes = [...extra, ...rawApprovedReviewNodes];
-    }
-    // Paginate check contexts forward if the first page is incomplete.
-    let rawCheckNodes = requireContextNodes(raw.commits.nodes[0]?.commit.statusCheckRollup?.contexts.nodes ?? []);
-    const checksPageInfo = raw.commits.nodes[0]?.commit.statusCheckRollup?.contexts.pageInfo;
-    const firstOid = raw.commits.nodes[0]?.commit.oid;
-    if (checksPageInfo?.hasNextPage && checksPageInfo.endCursor) {
-        // Pass endCursor so paginateForward fetches pages *after* the already-
-        // fetched first page instead of re-fetching it from the start.
-        let pageCount = 0;
-        const extra = await paginateForward(async (cursor) => {
-            const res = await graphql(BATCH_PR_QUERY, {
-                owner: repo.owner,
-                repo: repo.name,
-                pr,
-                ...(cursor ? { checksCursor: cursor } : {}),
-            });
-            const pr2 = requireRawPr(res.data, pr, repo);
-            if (!pr2?.commits.nodes[0]?.commit.statusCheckRollup) {
-                throw new Error(`Check-context pagination interrupted: statusCheckRollup disappeared on page ${pageCount + 2} (possible force-push race). Retry after the push stabilizes.`);
-            }
-            const currentOid = pr2.commits.nodes[0]?.commit.oid;
-            if (firstOid !== undefined && currentOid !== undefined && currentOid !== firstOid) {
-                throw new Error(`Check-context pagination interrupted: head commit changed from ${firstOid} to ${currentOid} between pages (force-push race). Retry.`);
-            }
-            pageCount++;
-            const ctxs = pr2.commits.nodes[0]?.commit.statusCheckRollup?.contexts;
-            if (!ctxs)
-                return { pageInfo: { hasNextPage: false, endCursor: null }, nodes: [] };
-            return { ...ctxs, nodes: requireContextNodes(ctxs.nodes) };
-        }, checksPageInfo.endCursor);
-        rawCheckNodes = [...rawCheckNodes, ...extra];
-    }
-    const data = parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes, rawReviewSummaryNodes, rawApprovedReviewNodes, rawCheckNodes);
-    return { data, rateLimit: result.rateLimit };
+    const paged = await paginateBatchConnections(pr, repo, raw, opts, result.rateLimit);
+    const rawThreadPages = await hydrateThreadCommentPages(paged.threads);
+    const data = parseRawPr(raw, rawThreadPages, paged.comments, paged.changesRequested, paged.reviewSummaries, paged.approvedReviews, paged.checks);
+    data.checks = mergeStartupFailureChecks(data.checks, parseSuiteStartupFailures(raw));
+    return {
+        data,
+        rateLimit: paged.rateLimit ?? result.rateLimit,
+        ...(parseCheckSuitesComplete(raw) && { checkSuitesComplete: true }),
+    };
 }

package/bin/github/branch-protection.d.mts

@@ -0,0 +1,3 @@
+import type { BatchPrData } from "../types.mts";
+import type { RawPr } from "./batch-raw-types.mts";
+export declare function parseBranchProtection(raw: RawPr): BatchPrData["branchProtection"];

package/bin/github/check-annotations.d.mts

@@ -0,0 +1,2 @@
+import type { CheckAnnotation } from "../types.mts";
+export declare function fetchCheckRunAnnotations(checkRunId: string): Promise<CheckAnnotation[]>;