pr-shepherd 0.56.5 → 0.57.0

package/bin/github/rest-reader-core.d.mts

@@ -0,0 +1,16 @@
+import type { RepoInfo, RateLimitInfo } from "./client.mts";
+export declare function restRepoPath(repo: RepoInfo): string;
+export declare function malformedRest(detail: string): never;
+export declare function restObject(value: unknown, label: string): Record<string, unknown>;
+export declare function restString(value: unknown, label: string): string;
+export declare function restNumber(value: unknown, label: string): number;
+export declare function restBoolean(value: unknown, label: string): boolean;
+export declare function restArray(value: unknown, label: string): unknown[];
+/** Counted REST envelopes must include the count as well as their list. */
+export declare function restCollection(value: unknown, key: string): unknown[];
+/** Complete REST connections; follow GitHub's Link, never infer completeness from a short page. */
+export declare function readRestPages<T>(path: string, select?: (body: unknown) => T[]): Promise<{
+    nodes: T[];
+    rateLimit?: RateLimitInfo;
+}>;
+export declare function readRest<T>(method: string, path: string, body?: unknown): Promise<T>;

package/bin/github/rest-reader-core.mjs

@@ -0,0 +1,154 @@
+import { restWithRateLimit } from "./http.mjs";
+import { GitHubRequestError } from "./errors.mjs";
+import { EXIT } from "../exit-codes.mjs";
+import { currentRestConditionalKey, recordRestConditionalRead } from "./rest-conditional-scope.mjs";
+export function restRepoPath(repo) {
+    return `/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.name)}`;
+}
+export function malformedRest(detail) {
+    throw new GitHubRequestError(`Malformed or incomplete GitHub REST response: ${detail}`, {
+        status: 200,
+        exitCodeOverride: EXIT.SOFTWARE,
+    });
+}
+export function restObject(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        malformedRest(label);
+    return value;
+}
+export function restString(value, label) {
+    if (typeof value !== "string" || !value)
+        malformedRest(label);
+    return value;
+}
+export function restNumber(value, label) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        malformedRest(label);
+    return value;
+}
+export function restBoolean(value, label) {
+    if (typeof value !== "boolean")
+        malformedRest(label);
+    return value;
+}
+export function restArray(value, label) {
+    if (!Array.isArray(value))
+        malformedRest(label);
+    return value;
+}
+/** Counted REST envelopes must include the count as well as their list. */
+export function restCollection(value, key) {
+    const record = restObject(value, key);
+    restNumber(record.total_count, `${key}.total_count`);
+    return restArray(record[key], key);
+}
+const REST_PAGE_SIZE = 100;
+/** Complete REST connections; follow GitHub's Link, never infer completeness from a short page. */
+export async function readRestPages(path, select = (body) => restArray(body, path)) {
+    let next = `${path}${path.includes("?") ? "&" : "?"}per_page=${REST_PAGE_SIZE}`;
+    const visited = new Set();
+    const nodes = [];
+    let rateLimit;
+    let total;
+    while (next) {
+        if (visited.has(next) || visited.size >= 1_000)
+            malformedRest(`pagination cycle or limit at ${next}`);
+        visited.add(next);
+        let result = await readRestRequest("GET", next);
+        let page = select(result.data);
+        if (!Array.isArray(page))
+            malformedRest(`missing page at ${next}`);
+        // A full page's body (and ETag) stays the same when an item is appended past it; only its
+        // Link gains rel="next". A 304 can't prove the cached terminal Link is still current, so a
+        // full page without a next link is re-read fresh rather than hiding items on a later page.
+        if (result.status === 304 &&
+            page.length >= REST_PAGE_SIZE &&
+            nextRestPage(result.link, path) === undefined) {
+            result = await readRestRequest("GET", next, undefined, true);
+            page = select(result.data);
+            if (!Array.isArray(page))
+                malformedRest(`missing page at ${next}`);
+        }
+        rateLimit = result.rateLimit ?? rateLimit;
+        nodes.push(...page);
+        if (result.data &&
+            typeof result.data === "object" &&
+            !Array.isArray(result.data) &&
+            "total_count" in result.data) {
+            const count = restNumber(result.data.total_count, `${path}.total_count`);
+            if (total !== undefined && total !== count)
+                malformedRest(`${path} changed during pagination`);
+            total = count;
+        }
+        next = nextRestPage(result.link, path);
+        if (next && page.length === 0)
+            malformedRest(`${path}: empty page with next link`);
+    }
+    if (total !== undefined && nodes.length !== total)
+        malformedRest(`${path}: ${nodes.length} of ${total} items`);
+    return { nodes, rateLimit };
+}
+function nextRestPage(link, original) {
+    if (!link)
+        return undefined;
+    const entries = link.split(",");
+    const nextEntries = entries.filter((entry) => /rel="next"/.test(entry));
+    if (nextEntries.length === 0)
+        return undefined;
+    if (nextEntries.length !== 1)
+        malformedRest(`multiple next links for ${original}`);
+    const match = /^\s*<([^>]+)>;\s*rel="next"\s*$/.exec(nextEntries[0]);
+    if (!match)
+        malformedRest(`invalid pagination link for ${original}`);
+    const url = new URL(match[1], "https://api.github.com");
+    if (url.origin !== "https://api.github.com" || url.pathname !== original.split("?")[0])
+        malformedRest(`unsafe pagination link for ${original}`);
+    if (url.searchParams.get("per_page") !== "100")
+        malformedRest(`changed page size for ${original}`);
+    const source = new URL(original, "https://api.github.com");
+    for (const key of new Set(source.searchParams.keys())) {
+        if (key !== "page" &&
+            key !== "per_page" &&
+            JSON.stringify(url.searchParams.getAll(key)) !==
+                JSON.stringify(source.searchParams.getAll(key)))
+            malformedRest(`changed pagination filter for ${original}`);
+    }
+    return `${url.pathname}${url.search}`;
+}
+/** A pull request whose mergeability GitHub is still computing must be re-read, never replayed. */
+function isSettledBody(body) {
+    if (body === null || typeof body !== "object" || Array.isArray(body))
+        return true;
+    const record = body;
+    return record.mergeable !== null && record.mergeable_state !== "unknown";
+}
+let activeRequests = 0;
+const pendingRequests = [];
+/** Bound independent snapshots and nested connection reads to four HTTP requests together. */
+async function readRestRequest(method, path, body, revalidate = false) {
+    if (activeRequests >= 4)
+        await new Promise((resolve) => pendingRequests.push(resolve));
+    else
+        activeRequests++;
+    try {
+        const key = method === "GET" ? currentRestConditionalKey() : undefined;
+        if (key === undefined)
+            return await restWithRateLimit(method, path, body);
+        const result = await restWithRateLimit(method, path, body, {
+            conditional: { key, name: path, shouldStore: isSettledBody, revalidate },
+        });
+        const unvalidated = result.status !== 304 && result.etag === undefined && isSettledBody(result.data);
+        recordRestConditionalRead(path, result.status === 304, result.etag, unvalidated ? result.data : undefined);
+        return result;
+    }
+    finally {
+        const waiting = pendingRequests.shift();
+        if (waiting)
+            waiting();
+        else
+            activeRequests--;
+    }
+}
+export async function readRest(method, path, body) {
+    return (await readRestRequest(method, path, body)).data;
+}

package/bin/github/rest-review-read.d.mts

@@ -0,0 +1,11 @@
+import type { RestReview } from "./rest-feedback-read.mts";
+export declare function validateRestReviews(reviews: RestReview[]): void;
+/** Draft reviews carry no submitted decision and cannot replace earlier submitted evidence. */
+export declare function restLatestReviews(reviews: RestReview[]): Map<string, {
+    login: string;
+    state: string;
+}>;
+export declare function restPendingReviews(reviews: RestReview[]): {
+    login: string;
+    state: string;
+}[];

package/bin/github/rest-review-read.mjs

@@ -0,0 +1,47 @@
+import { malformedRest, restString } from "./rest-reader-core.mjs";
+const REVIEW_STATES = new Set([
+    "APPROVED",
+    "CHANGES_REQUESTED",
+    "COMMENTED",
+    "DISMISSED",
+    "PENDING",
+]);
+export function validateRestReviews(reviews) {
+    for (const review of reviews) {
+        if (!REVIEW_STATES.has(restString(review.state, "review state")))
+            malformedRest("unknown review state");
+        restString(review.commit_id, "review commit_id");
+        if (review.state === "PENDING")
+            continue;
+        const submitted = restString(review.submitted_at, "review submitted_at");
+        if (!Number.isFinite(Date.parse(submitted)))
+            malformedRest("review submitted_at");
+    }
+}
+/** Draft reviews carry no submitted decision and cannot replace earlier submitted evidence. */
+export function restLatestReviews(reviews) {
+    const latest = new Map();
+    const submitted = reviews.filter((review) => review.state !== "PENDING");
+    submitted.sort((a, b) => Date.parse(a.submitted_at) - Date.parse(b.submitted_at) || a.id - b.id);
+    for (const review of submitted) {
+        if (!review.user?.login)
+            continue;
+        latest.set(review.user.login.toLowerCase(), {
+            login: review.user.login,
+            state: review.state,
+        });
+    }
+    return latest;
+}
+export function restPendingReviews(reviews) {
+    const pending = new Map();
+    for (const review of reviews) {
+        if (review.state !== "PENDING" || !review.user?.login)
+            continue;
+        pending.set(review.user.login.toLowerCase(), {
+            login: review.user.login,
+            state: review.state,
+        });
+    }
+    return [...pending.values()];
+}

package/bin/github/rest-rules-read.d.mts

@@ -0,0 +1,9 @@
+import type { RepoInfo } from "./client.mts";
+import type { RawBaseRef } from "./batch-raw-rules.mts";
+export declare function readRestBranchRules(repo: RepoInfo, branch: string): Promise<{
+    baseRef?: RawBaseRef;
+    unavailable: Array<{
+        field: string;
+        reason: string;
+    }>;
+}>;

package/bin/github/rest-rules-read.mjs

@@ -0,0 +1,154 @@
+import { readRest as rest } from "./rest-reader-core.mjs";
+import { GitHubRequestError } from "./errors.mjs";
+import { rateLimitKind } from "./rate-limit-kind.mjs";
+import { isRestSessionRefusal } from "./rest-session-refusal.mjs";
+import { recordRestConditionalRead } from "./rest-conditional-scope.mjs";
+import { readRestPages, restRepoPath, restObject, restString, restArray, restNumber, } from "./rest-reader-core.mjs";
+export async function readRestBranchRules(repo, branch) {
+    const path = `${restRepoPath(repo)}/branches/${encodeURIComponent(branch)}/protection`;
+    let classic = null;
+    const unavailable = [];
+    if (!(await classicProtectionDisabled(repo, branch))) {
+        try {
+            const data = restObject(await rest("GET", path), "branch protection");
+            const approvals = data.required_pull_request_reviews == null
+                ? null
+                : restObject(data.required_pull_request_reviews, "required reviews");
+            const checks = data.required_status_checks == null
+                ? null
+                : restObject(data.required_status_checks, "required checks");
+            classic = {
+                requiresApprovingReviews: approvals !== null,
+                requiredApprovingReviewCount: approvals
+                    ? restNumber(approvals.required_approving_review_count, "required approval count")
+                    : 0,
+                requiresConversationResolution: enabled(data.required_conversation_resolution),
+                requiresStatusChecks: checks !== null,
+                requiredStatusCheckContexts: checks
+                    ? restArray(checks.contexts, "check contexts").map((context) => restString(context, "check context"))
+                    : [],
+                requiresCodeOwnerReviews: approvals?.require_code_owner_reviews === true,
+                requireLastPushApproval: approvals?.require_last_push_approval === true,
+                requiresCommitSignatures: enabled(data.required_signatures),
+                requiresLinearHistory: enabled(data.required_linear_history),
+                requiresStrictStatusChecks: checks?.strict === true,
+            };
+        }
+        catch (error) {
+            if (!isUnavailablePolicy(error))
+                throw error;
+            // Only GitHub's explicit unprotected response proves absence. A generic
+            // 404 may hide protection from a token without administration access.
+            if (!isUnprotectedBranch(error))
+                unavailable.push({
+                    field: "branchProtection",
+                    reason: `Classic branch protection unavailable (HTTP ${error.status})`,
+                });
+        }
+    }
+    let rules;
+    try {
+        const data = await readRestPages(`${restRepoPath(repo)}/rules/branches/${encodeURIComponent(branch)}`);
+        rules = data.nodes.map((rule) => {
+            const type = restString(rule.type, "branch rule type").toUpperCase();
+            const p = rule.parameters == null ? {} : restObject(rule.parameters, "branch rule parameters");
+            return {
+                type,
+                parameters: {
+                    ...(p.required_approving_review_count !== undefined && {
+                        requiredApprovingReviewCount: restNumber(p.required_approving_review_count, "ruleset approval count"),
+                    }),
+                    ...(p.required_review_thread_resolution !== undefined && {
+                        requiredReviewThreadResolution: p.required_review_thread_resolution === true,
+                    }),
+                    ...(p.require_code_owner_review !== undefined && {
+                        requireCodeOwnerReview: p.require_code_owner_review === true,
+                    }),
+                    ...(p.require_last_push_approval !== undefined && {
+                        requireLastPushApproval: p.require_last_push_approval === true,
+                    }),
+                    ...(p.strict_required_status_checks_policy !== undefined && {
+                        strictRequiredStatusChecksPolicy: p.strict_required_status_checks_policy === true,
+                    }),
+                    ...(p.required_status_checks !== undefined && {
+                        requiredStatusChecks: restArray(p.required_status_checks, "ruleset status checks").map((check) => ({
+                            context: restString(restObject(check, "status check").context, "required context"),
+                        })),
+                    }),
+                    ...(p.required_deployment_environments !== undefined && {
+                        requiredDeploymentEnvironments: restArray(p.required_deployment_environments, "required deployments").map((environment) => restString(environment, "deployment environment")),
+                    }),
+                },
+            };
+        });
+    }
+    catch (error) {
+        if (!isUnavailablePolicy(error))
+            throw error;
+        unavailable.push({
+            field: "branchRules",
+            reason: `Branch rules unavailable (HTTP ${error.status})`,
+        });
+    }
+    // Preserve partial known policy, but keep incompleteness explicit to READY consumers.
+    const baseRef = classic !== null || rules !== undefined
+        ? {
+            branchProtectionRule: classic,
+            rules: rules === undefined ? null : { pageInfo: { hasNextPage: false }, nodes: rules },
+        }
+        : undefined;
+    return { ...(baseRef && { baseRef }), unavailable };
+}
+/**
+ * The branch summary is conditional (a 304 costs no quota) while an unprotected branch's
+ * `/protection` 404 is charged on every read. Its `commit.sha` also makes a base push visible
+ * to REST snapshot reuse. `protection.enabled: false` is GitHub's own
+ * "Branch not protected" answer, so the charged read is skipped. Any other shape, including a
+ * summary hidden from the token, falls through to the authoritative `/protection` read.
+ */
+async function classicProtectionDisabled(repo, branch) {
+    const path = `${restRepoPath(repo)}/branches/${encodeURIComponent(branch)}`;
+    let summary;
+    try {
+        summary = await rest("GET", path);
+    }
+    catch (error) {
+        if (!isUnavailablePolicy(error))
+            throw error;
+        // The summary's `commit.sha` is what tells snapshot reuse the base moved; without it, an
+        // unchanged pull body cannot prove mergeability, so the snapshot must not be replayed.
+        recordRestConditionalRead(path, false, undefined);
+        return false;
+    }
+    if (!summary || typeof summary !== "object" || Array.isArray(summary))
+        return false;
+    const protection = summary.protection;
+    if (!protection || typeof protection !== "object" || Array.isArray(protection))
+        return false;
+    return protection.enabled === false;
+}
+function isUnavailablePolicy(error) {
+    return (error instanceof GitHubRequestError &&
+        [403, 404].includes(error.status) &&
+        rateLimitKind(error) === null &&
+        !isRestSessionRefusal(error));
+}
+function isUnprotectedBranch(error) {
+    if (error.status !== 404)
+        return false;
+    try {
+        const body = JSON.parse(error.responseMessage ?? "");
+        return (body !== null &&
+            typeof body === "object" &&
+            !Array.isArray(body) &&
+            body["message"] === "Branch not protected");
+    }
+    catch {
+        return false;
+    }
+}
+function enabled(value) {
+    return (value !== null &&
+        value !== undefined &&
+        restObject(value, "protection requirement").enabled === true);
+}

package/bin/github/rest-session-refusal.d.mts

@@ -0,0 +1,5 @@
+import { GitHubRequestError } from "./errors.mts";
+/** A cloud proxy refusal says nothing about the viewer's GitHub authorization. */
+export declare function isRestSessionRefusal(error: unknown): error is GitHubRequestError;
+/** Inspect the response before normal error-message truncation hides its evidence. */
+export declare function isRestSessionRefusalResponse(status: number, raw: string): boolean;

package/bin/github/rest-session-refusal.mjs

@@ -0,0 +1,21 @@
+import { GitHubRequestError } from "./errors.mjs";
+/** A cloud proxy refusal says nothing about the viewer's GitHub authorization. */
+export function isRestSessionRefusal(error) {
+    return (error instanceof GitHubRequestError &&
+        isRestSessionRefusalResponse(error.status, error.responseMessage ?? error.message));
+}
+/** Inspect the response before normal error-message truncation hides its evidence. */
+export function isRestSessionRefusalResponse(status, raw) {
+    if (status !== 403)
+        return false;
+    if (/not enabled for this session|sessions are bound/i.test(raw))
+        return true;
+    try {
+        const payload = JSON.parse(raw);
+        return (typeof payload?.documentation_url === "string" &&
+            new URL(payload.documentation_url).hostname === "docs.anthropic.com");
+    }
+    catch {
+        return false;
+    }
+}

package/bin/github/rest-snapshot-context.d.mts

@@ -0,0 +1,10 @@
+import type { readRestStackMembership } from "./rest-stack-read.mts";
+import type { readRestBranchRules } from "./rest-rules-read.mts";
+/** Shared evidence belongs to one stack summary read, never to a later polling tick. */
+export interface RestSnapshotContext {
+    stack: Awaited<ReturnType<typeof readRestStackMembership>>;
+    repository: Record<string, unknown>;
+    viewerLogin: string | null;
+    readBranchRules(branch: string): ReturnType<typeof readRestBranchRules>;
+    recordPullRevision(pr: number, revision: string): void;
+}

package/bin/github/rest-snapshot-context.mjs

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

package/bin/github/rest-stack-read.d.mts

@@ -0,0 +1,21 @@
+import type { RepoInfo } from "./client.mts";
+import type { StackRead, StackMemberRefs } from "./stack-read.mts";
+interface RestStack {
+    number: number;
+    node_id: string;
+    base: {
+        ref: string;
+    };
+    pull_requests: Array<{
+        number: number;
+    }>;
+}
+/** The official native-stack endpoint is authoritative; missing API access cannot prove standalone membership. */
+export declare function readRestStackMembership(anchor: number, repo: RepoInfo): Promise<RestStack | null>;
+/**
+ * Topology reads are conditional. Outside a PR snapshot (iterate's stale-ancestry check runs after
+ * the snapshot returns) they use the anchor PR's ETag cache, so reads the snapshot already made
+ * (the stack list, the stack, the anchor's pull, `/user`) and the repeat membership read answer 304.
+ */
+export declare function readRestStackTopology(anchor: number, repo: RepoInfo): Promise<StackRead<StackMemberRefs>>;
+export {};

package/bin/github/rest-stack-read.mjs

@@ -0,0 +1,47 @@
+import { readRest as rest } from "./rest-reader-core.mjs";
+import { readRestPages, restRepoPath, restObject, restString, restNumber, restArray, malformedRest, } from "./rest-reader-core.mjs";
+import { readRestPull, restPullRefs } from "./rest-pr-core.mjs";
+import { mapPool } from "../util/pool.mjs";
+import { readRestViewerLogin } from "./rest-viewer-read.mjs";
+import { currentRestConditionalKey, withRestConditionalScope } from "./rest-conditional-scope.mjs";
+/** The official native-stack endpoint is authoritative; missing API access cannot prove standalone membership. */
+export async function readRestStackMembership(anchor, repo) {
+    const listed = (await readRestPages(`${restRepoPath(repo)}/stacks?pull_request=${anchor}`)).nodes;
+    if (listed.length === 0)
+        return null;
+    if (listed.length !== 1)
+        malformedRest("multiple native stacks for one PR");
+    const number = restNumber(listed[0].number, "stack number");
+    const stack = restObject(await rest("GET", `${restRepoPath(repo)}/stacks/${number}`), "stack");
+    if (restNumber(stack.number, "stack number") !== number)
+        malformedRest("stack identity drift");
+    restString(stack.node_id, "stack node_id");
+    restString(stack.base?.ref, "stack base ref");
+    restArray(stack.pull_requests, "stack pull_requests");
+    const numbers = stack.pull_requests.map((pull) => restNumber(pull.number, "stack member number"));
+    if (!numbers.includes(anchor) || new Set(numbers).size !== numbers.length)
+        malformedRest("stack membership omitted anchor or repeated member");
+    return stack;
+}
+/**
+ * Topology reads are conditional. Outside a PR snapshot (iterate's stale-ancestry check runs after
+ * the snapshot returns) they use the anchor PR's ETag cache, so reads the snapshot already made
+ * (the stack list, the stack, the anchor's pull, `/user`) and the repeat membership read answer 304.
+ */
+export function readRestStackTopology(anchor, repo) {
+    if (currentRestConditionalKey() !== undefined)
+        return readTopology(anchor, repo);
+    return withRestConditionalScope({ owner: repo.owner, repo: repo.name, pr: anchor }, () => readTopology(anchor, repo));
+}
+async function readTopology(anchor, repo) {
+    const stack = await readRestStackMembership(anchor, repo);
+    if (!stack)
+        throw new Error(`PR #${anchor} is not part of a native GitHub stack`);
+    const ordered = await mapPool(stack.pull_requests, 4, async (pull) => restPullRefs(await readRestPull(pull.number, repo)));
+    const verified = await readRestStackMembership(anchor, repo);
+    if (!verified || JSON.stringify(verified) !== JSON.stringify(stack))
+        malformedRest("native stack changed during topology read");
+    // Installation tokens may read native stacks without supporting authenticated-user identity.
+    const viewerLogin = await readRestViewerLogin();
+    return { stackNumber: stack.number, stackSize: ordered.length, ordered, viewerLogin };
+}

package/bin/github/rest-stack-summary.d.mts

@@ -0,0 +1,8 @@
+import type { RepoInfo } from "./client.mts";
+export declare function readRestStackSummary(anchor: number, repo: RepoInfo): Promise<{
+    stackNumber: number;
+    stackSize: number;
+    viewerLogin: string | null;
+    ordered: import("./poll-summary-raw.mts").RawSummaryPr[];
+    allowedMergeMethods?: import("../config/merge-method.mts").MergeMethod[] | undefined;
+}>;

package/bin/github/rest-stack-summary.mjs

@@ -0,0 +1,62 @@
+import { readRest, restRepoPath, restObject } from "./rest-reader-core.mjs";
+import { readRestViewerLogin } from "./rest-viewer-read.mjs";
+import { readAllowedMergeMethods } from "../config/merge-method.mjs";
+import { readRestStackMembership } from "./rest-stack-read.mjs";
+import { fetchRestRawSummaryPr } from "./rest-batch-read.mjs";
+import { mapPool } from "../util/pool.mjs";
+import { EXIT, ShepherdError } from "../exit-codes.mjs";
+import { GitHubRequestError } from "./errors.mjs";
+import { readRestPull, restPullRevision } from "./rest-pr-core.mjs";
+import { readRestBranchRules } from "./rest-rules-read.mjs";
+export async function readRestStackSummary(anchor, repo) {
+    const stack = await readRestStackMembership(anchor, repo);
+    if (!stack)
+        throw new ShepherdError(`PR #${anchor} is not part of a native GitHub stack`, EXIT.UNAVAILABLE);
+    const settings = restObject(await readRest("GET", restRepoPath(repo)), "repository merge settings");
+    const viewerLogin = await readRestViewerLogin();
+    const branchRules = new Map();
+    const pullRevisions = new Map();
+    const context = {
+        stack,
+        repository: settings,
+        viewerLogin,
+        readBranchRules(branch) {
+            let rules = branchRules.get(branch);
+            if (!rules) {
+                rules = readRestBranchRules(repo, branch);
+                branchRules.set(branch, rules);
+            }
+            return rules;
+        },
+        recordPullRevision(pr, revision) {
+            pullRevisions.set(pr, revision);
+        },
+    };
+    const ordered = await mapPool(stack.pull_requests, 4, (member) => fetchRestRawSummaryPr(member.number, repo, context));
+    await mapPool(ordered, 4, async (member) => {
+        const latest = await readRestPull(member.number, repo);
+        if (restPullRevision(latest) !== pullRevisions.get(member.number))
+            stackChanged();
+    });
+    const fresh = await readRestStackMembership(anchor, repo);
+    if (!fresh || JSON.stringify(fresh) !== JSON.stringify(stack))
+        stackChanged();
+    const allowedMergeMethods = readAllowedMergeMethods({
+        mergeCommitAllowed: typeof settings.allow_merge_commit === "boolean" ? settings.allow_merge_commit : undefined,
+        squashMergeAllowed: typeof settings.allow_squash_merge === "boolean" ? settings.allow_squash_merge : undefined,
+        rebaseMergeAllowed: typeof settings.allow_rebase_merge === "boolean" ? settings.allow_rebase_merge : undefined,
+    });
+    return {
+        stackNumber: stack.number,
+        stackSize: ordered.length,
+        viewerLogin,
+        ordered,
+        ...(allowedMergeMethods && { allowedMergeMethods }),
+    };
+}
+function stackChanged() {
+    throw new GitHubRequestError("Native stack changed during REST summary read; retry", {
+        status: 409,
+        exitCodeOverride: EXIT.TEMPFAIL,
+    });
+}

package/bin/github/rest-summary-read.d.mts

@@ -0,0 +1,7 @@
+import type { BatchPrData } from "../types.mts";
+import type { RawSummaryPr } from "./poll-summary-raw.mts";
+import type { RestPull } from "./rest-pr-core.mts";
+import type { readRestFeedback } from "./rest-feedback-read.mts";
+import type { readRestCommitChecks } from "./rest-check-read.mts";
+import type { readRestBranchRules } from "./rest-rules-read.mts";
+export declare function restSummary(data: BatchPrData, pull: RestPull, feedback: Awaited<ReturnType<typeof readRestFeedback>>, checks: Awaited<ReturnType<typeof readRestCommitChecks>>, baseRef: Awaited<ReturnType<typeof readRestBranchRules>>["baseRef"]): RawSummaryPr;