@ycodium-ai/plugin-pull-requests 0.2.0

package/dist/index.js

@@ -0,0 +1,4688 @@
+// src/index.ts
+import { definePlugin } from "@ycodium-ai/plugin-api";
+
+// src/service/backoff.ts
+var FALLBACK_COOLDOWN_MS = 3e4;
+var MAX_FALLBACK_COOLDOWN_MS = 15 * 6e4;
+var fallbackCooldownMs = (attempt) => Math.min(FALLBACK_COOLDOWN_MS * 2 ** Math.max(0, attempt - 1), MAX_FALLBACK_COOLDOWN_MS);
+var createBackoff = (options) => {
+  const now = options?.now ?? Date.now;
+  const entries = /* @__PURE__ */ new Map();
+  const keyOf = (input) => `${input.provider}\0${input.host.trim().toLowerCase()}`;
+  return {
+    check: (key, checkOptions) => {
+      const entry = entries.get(keyOf(key));
+      const at2 = now();
+      if (entry !== void 0 && entry.retryAt > at2 && checkOptions?.allowPaused !== true) {
+        return {
+          provider: key.provider,
+          host: key.host.trim().toLowerCase(),
+          retryAt: entry.retryAt
+        };
+      }
+      return { lease: entry?.generation ?? 0 };
+    },
+    recordRateLimit: (input) => {
+      const key = keyOf(input);
+      const at2 = now();
+      const previous = entries.get(key);
+      if (previous !== void 0 && previous.generation > input.lease) {
+        if (previous.retryAt <= at2 && (input.retryAt === void 0 || input.retryAt <= at2)) return;
+        const retryAt = input.retryAt !== void 0 && input.retryAt > previous.retryAt ? input.retryAt : previous.retryAt;
+        if (retryAt === previous.retryAt) return;
+        entries.set(key, { ...previous, retryAt });
+        return;
+      }
+      const attempt = (previous?.attempt ?? 0) + 1;
+      const proposed = input.retryAt !== void 0 && input.retryAt > at2 ? input.retryAt : at2 + fallbackCooldownMs(attempt);
+      entries.set(key, {
+        attempt,
+        generation: Math.max(previous?.generation ?? 0, input.lease) + 1,
+        retryAt: previous !== void 0 && previous.retryAt > at2 ? Math.max(previous.retryAt, proposed) : proposed
+      });
+    },
+    recordSuccess: (input) => {
+      const key = keyOf(input);
+      const previous = entries.get(key);
+      if (previous === void 0 || previous.generation !== input.lease || previous.retryAt > now()) {
+        return;
+      }
+      entries.set(key, { attempt: 0, generation: previous.generation, retryAt: 0 });
+    }
+  };
+};
+var isPaused = (result) => "retryAt" in result;
+
+// src/service/cache.ts
+var createCache = (options) => {
+  const now = options.now ?? Date.now;
+  const held = /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Map();
+  const record = (key, value) => {
+    held.delete(key);
+    if (held.size >= options.capacity) {
+      const oldest = held.keys().next().value;
+      if (oldest !== void 0) held.delete(oldest);
+    }
+    held.set(key, { at: now(), value });
+  };
+  return {
+    get: (key, load) => {
+      const snapshot = held.get(key);
+      if (snapshot !== void 0 && now() - snapshot.at <= options.ttlMs(key)) {
+        return Promise.resolve(snapshot.value);
+      }
+      if (snapshot !== void 0) held.delete(key);
+      const running = inFlight.get(key);
+      if (running !== void 0) return running;
+      const started = load().then(
+        (value) => {
+          inFlight.delete(key);
+          record(key, value);
+          return value;
+        },
+        (error) => {
+          inFlight.delete(key);
+          throw error;
+        }
+      );
+      inFlight.set(key, started);
+      return started;
+    },
+    clear: () => {
+      held.clear();
+    },
+    size: () => held.size
+  };
+};
+var createStaleWindow = (options) => {
+  const now = options.now ?? Date.now;
+  const held = /* @__PURE__ */ new Map();
+  const record = (key, value) => {
+    held.delete(key);
+    if (held.size >= options.capacity) {
+      const oldest = held.keys().next().value;
+      if (oldest !== void 0) held.delete(oldest);
+    }
+    held.set(key, { at: now(), value });
+  };
+  return {
+    get: (key, read) => {
+      const recorded = () => read().then((value) => {
+        record(key, value);
+        return value;
+      });
+      const snapshot = held.get(key);
+      if (snapshot === void 0 || now() - snapshot.at > options.staleMs) return recorded();
+      void recorded().catch((error) => options.onRefreshFailure?.(error));
+      return Promise.resolve(snapshot.value);
+    },
+    clear: () => {
+      held.clear();
+    }
+  };
+};
+
+// src/service/cursor.ts
+var LIST_CURSOR_PATTERN = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2}))\|(\d{1,9})\|(\d{1,9}(?:,\d{1,9})*)?$/;
+var parseListCursor = (raw) => {
+  const match = LIST_CURSOR_PATTERN.exec(raw);
+  if (match === null) return null;
+  const seenAt = match[3];
+  return {
+    updatedBefore: match[1],
+    delivered: Number(match[2]),
+    seenAt: seenAt === void 0 ? [] : seenAt.split(",").map(Number)
+  };
+};
+var listCursorKey = (host, repository) => `${host} ${repository.toLowerCase()}`;
+var listCursorAt = (previous, boundary, fetched, deliveredCount) => {
+  const seenAt = [
+    ...previous?.updatedBefore === boundary ? previous.seenAt : [],
+    ...fetched.filter((item) => item.updatedAt === boundary).map((item) => item.number)
+  ];
+  return `${boundary}|${(previous?.delivered ?? 0) + deliveredCount}|${seenAt.join(",")}`;
+};
+var nextListCursor = (previous, fetched, delivered, cursorAdvance = delivered.length) => {
+  if (fetched.length === 0) return null;
+  const oldest = fetched.reduce((left, right) => right.updatedAt < left.updatedAt ? right : left);
+  return listCursorAt(previous, oldest.updatedAt, fetched, cursorAdvance);
+};
+var withoutAlreadySent = (cursor, items) => cursor === void 0 ? items : items.filter(
+  (item) => item.updatedAt !== cursor.updatedBefore || !cursor.seenAt.includes(item.number)
+);
+
+// src/service/errors.ts
+var PROVIDER_REQUIREMENT = {
+  github: {
+    tokenMissing: "Add a GitHub token to the Pull requests card under Settings \u2192 Plugins to browse pull requests on this host.",
+    tokenRejected: "GitHub rejected the configured token. Replace it in the Pull requests card under Settings \u2192 Plugins."
+  },
+  gitlab: {
+    tokenMissing: "Add a GitLab token to the Pull requests card under Settings \u2192 Plugins to browse merge requests on this host.",
+    tokenRejected: "GitLab rejected the configured token. Replace it in the Pull requests card under Settings \u2192 Plugins."
+  }
+};
+var unavailableMessage = (reason, provider) => {
+  const requirement = provider === void 0 ? void 0 : PROVIDER_REQUIREMENT[provider];
+  switch (reason) {
+    case "token-missing":
+      return requirement?.tokenMissing ?? "No token is configured for this host.";
+    case "token-rejected":
+      return requirement?.tokenRejected ?? "This host rejected the configured token.";
+    case "provider-unsupported":
+      return "Change requests cannot be browsed for this project's host yet.";
+  }
+};
+var providerRequirement = (provider, reason) => {
+  const requirement = PROVIDER_REQUIREMENT[provider];
+  if (requirement === void 0) return null;
+  switch (reason) {
+    case "token-missing":
+      return requirement.tokenMissing;
+    case "token-rejected":
+      return requirement.tokenRejected;
+    case "provider-unsupported":
+      return null;
+  }
+};
+var PullRequestUnavailable = class extends Error {
+  code;
+  data;
+  constructor(input) {
+    super(unavailableMessage(input.reason, input.provider));
+    this.name = "PullRequestUnavailable";
+    this.code = input.reason;
+    this.data = {
+      ...input.provider === void 0 ? {} : { provider: input.provider },
+      ...input.host === void 0 ? {} : { host: input.host }
+    };
+  }
+};
+var PullRequestOperationFailed = class extends Error {
+  code = "operation-failed";
+  data;
+  constructor(input) {
+    super(`Pull request operation ${input.operation} failed: ${input.detail}`);
+    this.name = "PullRequestOperationFailed";
+    this.data = {
+      operation: input.operation,
+      detail: input.detail,
+      ...input.retryAt === void 0 ? {} : { retryAt: input.retryAt }
+    };
+  }
+};
+
+// src/githubHttp.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_BYTES = 1024 * 1024;
+var DEFAULT_HOST = "github.com";
+var RESERVE_RATIO = 0.1;
+var CARD = "Settings \u2192 Plugins \u2192 Pull requests";
+var GitHubError = class extends Error {
+  code;
+  /** 只有限流会带：`{ retryAt: epoch ms }`。宿主原样透传给 port。 */
+  data;
+  constructor(input) {
+    super(`GitHub API failed in ${input.operation}: ${input.detail}`);
+    this.name = "GitHubError";
+    this.code = input.code;
+    if (input.data !== void 0) this.data = input.data;
+  }
+};
+var text = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+var normalizeHost = (value) => value.trim().replace(/^https?:\/\//i, "").replace(/\/+$/, "").toLowerCase();
+var configuredHost = (ctx) => normalizeHost(text(ctx.config["githubHost"]) ?? DEFAULT_HOST);
+var configuredToken = (ctx) => text(ctx.config["githubToken"]);
+var restBase = (host) => host === DEFAULT_HOST ? "https://api.github.com" : `https://${host}/api/v3`;
+var graphQlUrl = (host) => host === DEFAULT_HOST ? "https://api.github.com/graphql" : `https://${host}/api/graphql`;
+var RATE_LIMIT_SELECTION = "rateLimit { cost limit remaining resetAt }";
+var readBody = async (response, maxBytes) => {
+  const stream = response.body;
+  if (stream === null) return { body: "", truncated: false };
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let body = "";
+  let read = 0;
+  for (; ; ) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    const value = chunk.value;
+    if (value === void 0) continue;
+    if (read + value.byteLength > maxBytes) {
+      body += decoder.decode(value.subarray(0, maxBytes - read), { stream: true });
+      await reader.cancel();
+      return { body, truncated: true };
+    }
+    read += value.byteLength;
+    body += decoder.decode(value, { stream: true });
+  }
+  return { body: body + decoder.decode(), truncated: false };
+};
+var number = (value) => {
+  if (value === null) return null;
+  const parsed = Number(value.trim());
+  return Number.isFinite(parsed) ? parsed : null;
+};
+var retryAtFrom = (headers) => {
+  const after = number(headers.get("Retry-After"));
+  if (after !== null && after >= 0) return Date.now() + after * 1e3;
+  const reset = number(headers.get("x-ratelimit-reset"));
+  return reset !== null && reset > 0 ? reset * 1e3 : null;
+};
+var rateLimited = (input) => new GitHubError({
+  code: "rate-limited",
+  operation: input.operation,
+  detail: input.detail,
+  ...input.retryAt === null ? {} : { data: { retryAt: input.retryAt } }
+});
+var isRateLimitStatus = (status, headers) => {
+  if (status === 429) return true;
+  if (status !== 403) return false;
+  return number(headers.get("x-ratelimit-remaining")) === 0 || headers.get("Retry-After") !== null;
+};
+var statusError = (input) => {
+  if (isRateLimitStatus(input.status, input.headers)) {
+    return rateLimited({
+      operation: input.operation,
+      detail: `GitHub API rate limit exceeded (HTTP ${input.status}).`,
+      retryAt: retryAtFrom(input.headers)
+    });
+  }
+  if (input.status === 401 || input.status === 403) {
+    return new GitHubError({
+      code: "unauthenticated",
+      operation: input.operation,
+      detail: `GitHub refused the token (HTTP ${input.status}). Check the token and its \`repo\` scope in ${CARD}.`
+    });
+  }
+  return new GitHubError({
+    code: "failed",
+    operation: input.operation,
+    detail: `GitHub answered HTTP ${input.status}.`
+  });
+};
+var restBudgetError = (operation, headers) => {
+  const limit = number(headers.get("x-ratelimit-limit"));
+  const remaining = number(headers.get("x-ratelimit-remaining"));
+  if (limit === null || limit <= 0 || remaining === null || remaining < 0) return null;
+  if (remaining >= limit * RESERVE_RATIO) return null;
+  return rateLimited({
+    operation,
+    detail: `GitHub API quota is down to ${remaining} of ${limit}.`,
+    retryAt: retryAtFrom(headers)
+  });
+};
+var requestError = (operation, error) => {
+  const name = error instanceof Error ? error.name : "";
+  if (name === "TimeoutError" || name === "AbortError") {
+    return new GitHubError({
+      code: "failed",
+      operation,
+      detail: "GitHub did not answer before the timeout."
+    });
+  }
+  return new GitHubError({
+    code: "failed",
+    operation,
+    detail: error instanceof Error ? error.message : String(error)
+  });
+};
+var send = async (ctx, input) => {
+  const host = configuredHost(ctx);
+  const asked = input.host === void 0 ? null : normalizeHost(input.host);
+  if (asked !== null && asked.length > 0 && asked !== host) {
+    throw new GitHubError({
+      code: "unauthenticated",
+      operation: input.operation,
+      detail: `This repository lives on ${asked}, but ${CARD} is configured for ${host}.`
+    });
+  }
+  const token = configuredToken(ctx);
+  if (token === null) {
+    throw new GitHubError({
+      code: "missing-tool",
+      operation: input.operation,
+      detail: `No GitHub token is configured. Add a personal access token with the \`repo\` scope in ${CARD}.`
+    });
+  }
+  let response;
+  try {
+    response = await ctx.http(input.url(host), {
+      method: input.method ?? "GET",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: input.accept ?? "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+        "Content-Type": "application/json"
+      },
+      ...input.body === void 0 ? {} : { body: input.body },
+      signal: AbortSignal.timeout(input.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+    });
+  } catch (error) {
+    throw requestError(input.operation, error);
+  }
+  if (!response.ok) {
+    await response.body?.cancel();
+    throw statusError({
+      operation: input.operation,
+      status: response.status,
+      headers: response.headers
+    });
+  }
+  const budget = restBudgetError(input.operation, response.headers);
+  if (budget !== null) {
+    await response.body?.cancel();
+    throw budget;
+  }
+  try {
+    const read = await readBody(response, input.maxBytes ?? DEFAULT_MAX_BYTES);
+    return { ...read, headers: response.headers };
+  } catch (error) {
+    throw requestError(input.operation, error);
+  }
+};
+var callGitHubApi = (ctx, input) => send(ctx, { ...input, url: (host) => `${restBase(host)}/${input.path}` });
+var ORG_SCOPES = /* @__PURE__ */ new Set(["read:org", "admin:org", "read:discussion", "admin:discussion"]);
+var orgScopeByContext = /* @__PURE__ */ new WeakMap();
+var probeOrgScope = async (ctx, host) => {
+  const result = await callGitHubApi(ctx, {
+    operation: "readTokenScopes",
+    path: "user",
+    ...host === void 0 ? {} : { host }
+  });
+  const granted = result.headers.get("x-oauth-scopes");
+  if (granted === null) return false;
+  return granted.split(",").some((scope) => ORG_SCOPES.has(scope.trim().toLowerCase()));
+};
+var canReadOrg = (ctx, host) => {
+  const token = configuredToken(ctx);
+  if (token === null) return Promise.resolve(false);
+  const byToken = orgScopeByContext.get(ctx) ?? /* @__PURE__ */ new Map();
+  orgScopeByContext.set(ctx, byToken);
+  const cached = byToken.get(token);
+  if (cached !== void 0) return cached;
+  const probe = probeOrgScope(ctx, host).catch(() => {
+    byToken.delete(token);
+    return false;
+  });
+  byToken.set(token, probe);
+  return probe;
+};
+var readError = (operation, what) => new GitHubError({
+  code: "failed",
+  operation,
+  detail: `GitHub returned an unreadable ${what} response.`
+});
+var parse = (raw) => {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+};
+var asObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+var callGitHubJson = async (ctx, input) => {
+  const result = await callGitHubApi(ctx, input);
+  if (result.truncated) throw readError(input.operation, "JSON");
+  const parsed = parse(result.body.trim());
+  if (parsed === void 0) throw readError(input.operation, "JSON");
+  return parsed;
+};
+var graphQlBudgetError = (operation, data) => {
+  const rate = asObject(asObject(data)?.["rateLimit"]);
+  if (rate === null) return null;
+  const limit = typeof rate["limit"] === "number" ? rate["limit"] : null;
+  const remaining = typeof rate["remaining"] === "number" ? rate["remaining"] : null;
+  const cost = typeof rate["cost"] === "number" ? rate["cost"] : 0;
+  if (limit === null || limit <= 0 || remaining === null || remaining < 0) return null;
+  if (remaining - Math.max(1, cost) >= limit * RESERVE_RATIO) return null;
+  const resetAt = typeof rate["resetAt"] === "string" ? Date.parse(rate["resetAt"]) : Number.NaN;
+  return rateLimited({
+    operation,
+    detail: `GitHub GraphQL quota is down to ${remaining} of ${limit}.`,
+    retryAt: Number.isFinite(resetAt) ? resetAt : null
+  });
+};
+var INSUFFICIENT_SCOPES = "INSUFFICIENT_SCOPES";
+var errorTypes = (errors) => errors.map((entry) => text(asObject(entry)?.["type"])?.toUpperCase() ?? "");
+var errorPaths = (errors) => errors.flatMap((entry) => {
+  const path2 = asObject(entry)?.["path"];
+  return Array.isArray(path2) ? [path2.map((part) => String(part)).join(".")] : [];
+});
+var graphQlError = (operation, errors) => {
+  const types = errorTypes(errors);
+  const message = text(asObject(errors[0])?.["message"]) ?? "GitHub rejected the query.";
+  if (types.includes("RATE_LIMITED")) {
+    return rateLimited({ operation, detail: message, retryAt: null });
+  }
+  if (types.includes("FORBIDDEN") || types.includes("INSUFFICIENT_SCOPES")) {
+    return new GitHubError({
+      code: "unauthenticated",
+      operation,
+      detail: `${message} Check the token and its scopes in ${CARD}.`
+    });
+  }
+  return new GitHubError({ code: "failed", operation, detail: message });
+};
+var callGitHubGraphQl = async (ctx, input) => {
+  const result = await send(ctx, {
+    operation: input.operation,
+    ...input.host === void 0 ? {} : { host: input.host },
+    ...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs },
+    url: (host) => graphQlUrl(host),
+    method: "POST",
+    body: JSON.stringify({ query: input.query, variables: input.variables ?? {} })
+  });
+  if (result.truncated) throw readError(input.operation, "GraphQL");
+  const parsed = asObject(parse(result.body.trim()));
+  if (parsed === null) throw readError(input.operation, "GraphQL");
+  const data = parsed["data"];
+  const errors = parsed["errors"];
+  if (Array.isArray(errors) && errors.length > 0) {
+    const droppable = asObject(data) !== null && errorTypes(errors).every((type) => type === INSUFFICIENT_SCOPES);
+    if (!droppable) throw graphQlError(input.operation, errors);
+    ctx.log.warn("github graphql dropped fields this token has no scope for", {
+      operation: input.operation,
+      paths: errorPaths(errors)
+    });
+  }
+  if (asObject(data) === null) throw readError(input.operation, "GraphQL");
+  const budget = graphQlBudgetError(input.operation, data);
+  if (budget !== null) throw budget;
+  return data;
+};
+
+// src/githubMapping.ts
+var asObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+var asArray = (value) => Array.isArray(value) ? value : [];
+var text2 = (value) => {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+};
+var int = (value) => typeof value === "number" && Number.isFinite(value) ? Math.trunc(value) : null;
+var at = (value, ...keys) => {
+  let current = value;
+  for (const key of keys) {
+    const object = asObject2(current);
+    if (object === null) return void 0;
+    current = object[key];
+  }
+  return current;
+};
+var nodes = (value) => asArray(at(value, "nodes"));
+var nextCursorOf = (value) => at(value, "pageInfo", "hasNextPage") === true ? text2(at(value, "pageInfo", "endCursor")) : null;
+var REACTION_BY_GITHUB = {
+  THUMBS_UP: "thumbs-up",
+  THUMBS_DOWN: "thumbs-down",
+  LAUGH: "laugh",
+  HOORAY: "hooray",
+  CONFUSED: "confused",
+  HEART: "heart",
+  ROCKET: "rocket",
+  EYES: "eyes"
+};
+var GITHUB_BY_REACTION = {
+  "thumbs-up": "THUMBS_UP",
+  "thumbs-down": "THUMBS_DOWN",
+  laugh: "LAUGH",
+  hooray: "HOORAY",
+  confused: "CONFUSED",
+  heart: "HEART",
+  rocket: "ROCKET",
+  eyes: "EYES"
+};
+var gitHubReactionContent = (content) => GITHUB_BY_REACTION[content];
+var REVIEW_EVENT_BY_VERDICT = {
+  comment: "COMMENT",
+  approve: "APPROVE",
+  "request-changes": "REQUEST_CHANGES"
+};
+var gitHubReviewPosition = (position) => {
+  switch (position.kind) {
+    case "added":
+      return { line: position.newLine, side: "RIGHT" };
+    case "deleted":
+      return { line: position.oldLine, side: "LEFT" };
+    case "context":
+      return position.side === "left" ? { line: position.oldLine, side: "LEFT" } : { line: position.newLine, side: "RIGHT" };
+  }
+};
+var toState = (raw) => {
+  if (text2(raw["mergedAt"]) !== null) return "merged";
+  switch (text2(raw["state"])?.toUpperCase()) {
+    case "MERGED":
+      return "merged";
+    case "CLOSED":
+      return "closed";
+    default:
+      return "open";
+  }
+};
+var toMergeability = (value) => {
+  switch (text2(value)?.toUpperCase()) {
+    case "MERGEABLE":
+      return "mergeable";
+    case "CONFLICTING":
+      return "conflicting";
+    default:
+      return "unknown";
+  }
+};
+var toReviewDecision = (value) => {
+  switch (text2(value)?.toUpperCase()) {
+    case "APPROVED":
+      return "approved";
+    case "CHANGES_REQUESTED":
+      return "changes-requested";
+    case "REVIEW_REQUIRED":
+      return "review-required";
+    default:
+      return null;
+  }
+};
+var toCheckStatus = (raw) => {
+  const status = text2(raw["status"])?.toUpperCase();
+  if (status !== void 0 && status !== "COMPLETED") return "pending";
+  switch (text2(raw["conclusion"] ?? raw["state"])?.toUpperCase()) {
+    case "SUCCESS":
+      return "success";
+    case "FAILURE":
+    case "ERROR":
+    case "TIMED_OUT":
+    case "STARTUP_FAILURE":
+    // 跑完了却要人手动介入的检查是拦路的，不是中性的。
+    case "ACTION_REQUIRED":
+      return "failure";
+    case "CANCELLED":
+      return "cancelled";
+    case "SKIPPED":
+      return "skipped";
+    case "PENDING":
+    case "EXPECTED":
+      return "pending";
+    default:
+      return "neutral";
+  }
+};
+var UNSET_TIMESTAMP = "0001-01-01T00:00:00Z";
+var realTimestamp = (value) => {
+  const stamp = text2(value);
+  return stamp === null || stamp === UNSET_TIMESTAMP ? null : stamp;
+};
+var isAtLeastAsNew = (candidate, kept) => candidate === null ? kept === null : kept === null || candidate >= kept;
+var dedupeChecks = (entries) => {
+  const newest = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const key = `${entry.workflowName ?? ""} ${entry.check.name}`;
+    const kept = newest.get(key);
+    if (kept === void 0 || isAtLeastAsNew(entry.at, kept.at)) newest.set(key, entry);
+  }
+  const survivors = [...newest.values()];
+  const countsByName = /* @__PURE__ */ new Map();
+  for (const entry of survivors) {
+    countsByName.set(entry.check.name, (countsByName.get(entry.check.name) ?? 0) + 1);
+  }
+  return survivors.map((entry) => {
+    const workflowName = entry.workflowName ?? "";
+    return workflowName.length > 0 && (countsByName.get(entry.check.name) ?? 0) > 1 ? { ...entry.check, name: `${workflowName} / ${entry.check.name}` } : entry.check;
+  });
+};
+var toChecks = (contexts) => dedupeChecks(
+  contexts.flatMap((entry) => {
+    const raw = asObject2(entry);
+    if (raw === null) return [];
+    const name = text2(raw["name"]) ?? text2(raw["context"]);
+    if (name === null) return [];
+    return [
+      {
+        check: {
+          name,
+          status: toCheckStatus(raw),
+          description: text2(raw["description"]) ?? text2(raw["title"]),
+          url: text2(raw["detailsUrl"]) ?? text2(raw["targetUrl"])
+        },
+        workflowName: text2(at(raw, "checkSuite", "workflowRun", "workflow", "name")),
+        at: realTimestamp(raw["completedAt"]) ?? realTimestamp(raw["startedAt"])
+      }
+    ];
+  })
+);
+var toChecksState = (value) => {
+  switch (text2(value)?.toUpperCase()) {
+    case "FAILURE":
+    case "ERROR":
+      return "failing";
+    case "PENDING":
+    case "EXPECTED":
+      return "pending";
+    case "SUCCESS":
+      return "passing";
+    default:
+      return null;
+  }
+};
+var checksStateFromChecks = (checks) => {
+  const statuses = checks.map((check) => check.status);
+  if (statuses.length === 0) return null;
+  if (statuses.includes("failure")) return "failing";
+  if (statuses.includes("pending")) return "pending";
+  return statuses.includes("success") ? "passing" : null;
+};
+var toActor = (value) => {
+  const raw = asObject2(value);
+  const login = text2(raw?.["login"]);
+  return login === null ? null : { login, name: text2(raw?.["name"]), avatarUrl: text2(raw?.["avatarUrl"]) };
+};
+var toCommitActor = (value) => {
+  const raw = asObject2(value);
+  const login = text2(at(raw, "user", "login")) ?? text2(raw?.["name"]);
+  return login === null ? null : { login, name: text2(raw?.["name"]), avatarUrl: text2(raw?.["avatarUrl"]) };
+};
+var toLabels = (value) => nodes(value).flatMap((entry) => {
+  const name = text2(asObject2(entry)?.["name"]);
+  return name === null ? [] : [{ name, color: text2(asObject2(entry)?.["color"]) }];
+});
+var REACTORS_PER_GROUP = 10;
+var toReactions = (value, viewer) => {
+  const normalizedViewer = viewer?.toLowerCase() ?? null;
+  const reactions = [];
+  for (const entry of asArray(value)) {
+    const group = asObject2(entry);
+    if (group === null) continue;
+    const content = REACTION_BY_GITHUB[text2(group["content"])?.toUpperCase() ?? ""];
+    if (content === void 0) continue;
+    const logins = nodes(group["reactors"]).flatMap(
+      (node) => text2(asObject2(node)?.["login"]) ?? []
+    );
+    const count = Math.max(
+      int(at(group, "reactors", "totalCount")) ?? logins.length,
+      logins.length
+    );
+    if (count <= 0) continue;
+    reactions.push({
+      content,
+      count,
+      actors: normalizedViewer === null ? logins : logins.filter((login) => login.toLowerCase() !== normalizedViewer),
+      viewerHasReacted: group["viewerHasReacted"] === true
+    });
+  }
+  return reactions;
+};
+var PAGE_SIZE = 100;
+var SEARCH_MAX_ROWS = PAGE_SIZE;
+var reactionGroups = (canReadOrg2) => `reactionGroups {
+  content
+  viewerHasReacted
+  reactors(first: ${REACTORS_PER_GROUP}) {
+    totalCount
+    nodes { ... on User { login } ... on Bot { login } ... on Mannequin { login } ... on Organization { ${canReadOrg2 ? "login" : "__typename"} } }
+  }
+}`;
+var ACTOR_FIELDS = "login avatarUrl ... on User { name }";
+var teamFragment = (canReadOrg2, fields) => `... on Team { __typename${canReadOrg2 ? ` ${fields}` : ""} }`;
+var rowFields = (input) => `number
+title
+url
+author { ${ACTOR_FIELDS} }
+headRefName
+baseRefName
+state
+isDraft
+mergeable
+reviewDecision
+createdAt
+updatedAt
+mergedAt
+${input.reviewRequests ? `reviewRequests(first: 20) { nodes { requestedReviewer { ... on User { login } ${teamFragment(input.canReadOrg, "slug")} } } }` : ""}
+labels(first: 20) { nodes { name color } }
+commits(last: 1) { nodes { commit { statusCheckRollup { state } } } }`;
+var clampRows = (rows) => Math.min(Math.max(Math.trunc(rows), 1), SEARCH_MAX_ROWS);
+var searchQueryDocument = (rows, canReadOrg2) => `query($q: String!) {
+  search(query: $q, type: ISSUE, first: ${clampRows(rows)}) {
+    pageInfo { hasNextPage }
+    nodes { ... on PullRequest { ${rowFields({ canReadOrg: canReadOrg2, reviewRequests: true })} repository { nameWithOwner } } }
+  }
+  ${RATE_LIMIT_SELECTION}
+}`;
+var repositorySearchQueryDocument = (rows, canReadOrg2) => `query($q: String!) {
+  search(query: $q, type: ISSUE, first: ${clampRows(rows)}) {
+    pageInfo { hasNextPage }
+    nodes { ... on PullRequest { ${rowFields({ canReadOrg: canReadOrg2, reviewRequests: true })} additions deletions } }
+  }
+  ${RATE_LIMIT_SELECTION}
+}`;
+var detailQueryDocument = (canReadOrg2) => `query($owner: String!, $name: String!, $number: Int!) {
+  repository(owner: $owner, name: $name) {
+    mergeCommitAllowed
+    squashMergeAllowed
+    rebaseMergeAllowed
+    viewerPermission
+    pullRequest(number: $number) {
+      ${rowFields({ canReadOrg: canReadOrg2, reviewRequests: false })}
+      additions
+      deletions
+      body
+      changedFiles
+      closedAt
+      viewerCanUpdate
+      viewerDidAuthor
+      viewerCanUpdateBranch
+      autoMergeRequest { enabledAt }
+      headRepositoryOwner { login }
+      reviewRequests(first: 50) {
+        nodes { requestedReviewer { ... on User { login name avatarUrl } ... on Bot { login avatarUrl } ${teamFragment(canReadOrg2, "slug name avatarUrl")} } }
+      }
+      commits(last: 1) {
+        nodes {
+          commit {
+            statusCheckRollup {
+              contexts(first: ${PAGE_SIZE}) {
+                nodes {
+                  ... on CheckRun {
+                    name status conclusion detailsUrl startedAt completedAt
+                    checkSuite { workflowRun { workflow { name } } }
+                  }
+                  ... on StatusContext { context state description targetUrl createdAt }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  ${RATE_LIMIT_SELECTION}
+}`;
+var BASE_COMPARISON_QUERY = `query($owner: String!, $name: String!, $number: Int!, $headRef: String!) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      viewerCanUpdateBranch
+      baseRef { compare(headRef: $headRef) { behindBy } }
+    }
+  }
+  ${RATE_LIMIT_SELECTION}
+}`;
+var activityQueryDocument = (canReadOrg2) => `query($owner: String!, $name: String!, $number: Int!, $cursor: String) {
+  viewer { login }
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      author { ${ACTOR_FIELDS} }
+      ${reactionGroups(canReadOrg2)}
+      reviewThreads(first: ${PAGE_SIZE}, after: $cursor) {
+        pageInfo { hasNextPage endCursor }
+        nodes {
+          id isResolved isOutdated path line diffSide
+          comments(first: 10) {
+            totalCount
+            pageInfo { hasNextPage endCursor }
+            nodes { id author { ${ACTOR_FIELDS} } body createdAt url ${reactionGroups(canReadOrg2)} }
+          }
+        }
+      }
+      comments(first: ${PAGE_SIZE}) {
+        pageInfo { hasNextPage }
+        nodes { id author { ${ACTOR_FIELDS} } body createdAt url ${reactionGroups(canReadOrg2)} }
+      }
+      reviews(first: ${PAGE_SIZE}) {
+        pageInfo { hasNextPage }
+        nodes { id author { ${ACTOR_FIELDS} } body state submittedAt url ${reactionGroups(canReadOrg2)} }
+      }
+      reviewRequests(first: 50) {
+        nodes { requestedReviewer { ... on User { login name avatarUrl } ... on Bot { login avatarUrl } } }
+      }
+      latestReviews(first: 50) { nodes { author { ${ACTOR_FIELDS} } } }
+      reviewDismissals: timelineItems(itemTypes: [REVIEW_DISMISSED_EVENT], first: ${PAGE_SIZE}) {
+        nodes { ... on ReviewDismissedEvent { dismissalMessage review { id } } }
+      }
+      commits(last: ${PAGE_SIZE}) {
+        nodes {
+          commit {
+            oid messageHeadline committedDate additions deletions
+            authors(first: 3) { nodes { name avatarUrl user { login } } }
+          }
+        }
+      }
+    }
+  }
+  ${RATE_LIMIT_SELECTION}
+}`;
+var threadCommentsQueryDocument = (canReadOrg2) => `query($owner: String!, $name: String!, $number: Int!, $threadId: ID!, $cursor: String) {
+  viewer { login }
+  repository(owner: $owner, name: $name) { pullRequest(number: $number) { id } }
+  node(id: $threadId) {
+    ... on PullRequestReviewThread {
+      pullRequest { id }
+      comments(first: ${PAGE_SIZE}, after: $cursor) {
+        pageInfo { hasNextPage endCursor }
+        nodes { id author { ${ACTOR_FIELDS} } body createdAt url ${reactionGroups(canReadOrg2)} }
+      }
+    }
+  }
+  ${RATE_LIMIT_SELECTION}
+}`;
+var VIEWER_PERMISSIONS_QUERY = `query($owner: String!, $name: String!, $number: Int!) {
+  repository(owner: $owner, name: $name) {
+    viewerPermission
+    pullRequest(number: $number) { viewerCanUpdate viewerDidAuthor viewerCanUpdateBranch }
+  }
+  ${RATE_LIMIT_SELECTION}
+}`;
+var reviewerCandidatesQueryDocument = (canReadOrg2) => `query($owner: String!, $name: String!, $number: Int!) {
+  repository(owner: $owner, name: $name) {
+    assignableUsers(first: ${PAGE_SIZE}) {
+      pageInfo { hasNextPage }
+      nodes { login name avatarUrl }
+    }
+    pullRequest(number: $number) {
+      author { login }
+      reviewRequests(first: ${PAGE_SIZE}) {
+        nodes { requestedReviewer { ... on User { login name avatarUrl } ${teamFragment(canReadOrg2, "slug name avatarUrl")} ... on Bot { login avatarUrl } } }
+      }
+    }
+  }
+  ${RATE_LIMIT_SELECTION}
+}`;
+var NODE_ID_QUERY = `query($owner: String!, $name: String!, $number: Int!) {
+  repository(owner: $owner, name: $name) { pullRequest(number: $number) { id } }
+  ${RATE_LIMIT_SELECTION}
+}`;
+var SUBJECT_SCOPE_QUERY = `query($owner: String!, $name: String!, $number: Int!, $subjectId: ID!) {
+  repository(owner: $owner, name: $name) { pullRequest(number: $number) { id } }
+  node(id: $subjectId) {
+    id
+    ... on IssueComment { pullRequest { id } }
+    ... on PullRequestReviewComment { pullRequest { id } }
+    ... on PullRequestReview { pullRequest { id } }
+  }
+  ${RATE_LIMIT_SELECTION}
+}`;
+var REPLY_MUTATION = `mutation($threadId: ID!, $body: String!) {
+  addPullRequestReviewThreadReply(input: { pullRequestReviewThreadId: $threadId, body: $body }) { comment { id } }
+}`;
+var RESOLVE_MUTATION = `mutation($threadId: ID!) {
+  resolveReviewThread(input: { threadId: $threadId }) { thread { isResolved } }
+}`;
+var UNRESOLVE_MUTATION = `mutation($threadId: ID!) {
+  unresolveReviewThread(input: { threadId: $threadId }) { thread { isResolved } }
+}`;
+var ADD_REACTION_MUTATION = `mutation($subjectId: ID!, $content: ReactionContent!) {
+  addReaction(input: { subjectId: $subjectId, content: $content }) { reaction { content } }
+}`;
+var REMOVE_REACTION_MUTATION = `mutation($subjectId: ID!, $content: ReactionContent!) {
+  removeReaction(input: { subjectId: $subjectId, content: $content }) { reaction { content } }
+}`;
+var UPDATE_ISSUE_COMMENT_MUTATION = `mutation($commentId: ID!, $body: String!) {
+  updateIssueComment(input: { id: $commentId, body: $body }) { issueComment { id } }
+}`;
+var UPDATE_REVIEW_COMMENT_MUTATION = `mutation($commentId: ID!, $body: String!) {
+  updatePullRequestReviewComment(input: { pullRequestReviewCommentId: $commentId, body: $body }) {
+    pullRequestReviewComment { id }
+  }
+}`;
+var READY_MUTATION = `mutation($pullRequestId: ID!) {
+  markPullRequestReadyForReview(input: { pullRequestId: $pullRequestId }) { pullRequest { id } }
+}`;
+var DRAFT_MUTATION = `mutation($pullRequestId: ID!) {
+  convertPullRequestToDraft(input: { pullRequestId: $pullRequestId }) { pullRequest { id } }
+}`;
+var UPDATE_BRANCH_MUTATION = `mutation($pullRequestId: ID!, $updateMethod: PullRequestBranchUpdateMethod) {
+  updatePullRequestBranch(input: { pullRequestId: $pullRequestId, updateMethod: $updateMethod }) {
+    pullRequest { id }
+  }
+}`;
+var ENABLE_AUTO_MERGE_MUTATION = `mutation($pullRequestId: ID!, $mergeMethod: PullRequestMergeMethod) {
+  enablePullRequestAutoMerge(input: { pullRequestId: $pullRequestId, mergeMethod: $mergeMethod }) {
+    pullRequest { id }
+  }
+}`;
+var DISABLE_AUTO_MERGE_MUTATION = `mutation($pullRequestId: ID!) {
+  disablePullRequestAutoMerge(input: { pullRequestId: $pullRequestId }) { pullRequest { id } }
+}`;
+var REPOSITORY_PART = /^[A-Za-z0-9._-]+$/;
+var buildStatsQuery = (changeRequests) => {
+  if (changeRequests.length === 0) return null;
+  const selections = [];
+  for (const [index, changeRequest] of changeRequests.entries()) {
+    const [owner, name, ...rest] = changeRequest.repository.trim().split("/");
+    if (rest.length > 0 || owner === void 0 || name === void 0) return null;
+    if (!REPOSITORY_PART.test(owner) || !REPOSITORY_PART.test(name)) return null;
+    if (!Number.isSafeInteger(changeRequest.number) || changeRequest.number <= 0) return null;
+    selections.push(
+      `  s${index}: repository(owner: "${owner}", name: "${name}") { pullRequest(number: ${changeRequest.number}) { additions deletions } }`
+    );
+  }
+  return `query {
+${selections.join("\n")}
+  ${RATE_LIMIT_SELECTION}
+}`;
+};
+var decodeViewerLogin = (value) => text2(asObject2(value)?.["login"]);
+var toReviewRequestLogins = (value) => nodes(value).flatMap((node) => text2(at(node, "requestedReviewer", "login")) ?? []);
+var toRow = (raw) => {
+  const number2 = int(raw["number"]);
+  const title = text2(raw["title"]);
+  const url = text2(raw["url"]);
+  const headBranch = text2(raw["headRefName"]);
+  const baseBranch = text2(raw["baseRefName"]);
+  const createdAt = text2(raw["createdAt"]);
+  const updatedAt = text2(raw["updatedAt"]);
+  if (number2 === null || title === null || url === null || headBranch === null || baseBranch === null || createdAt === null || updatedAt === null) {
+    return null;
+  }
+  return {
+    number: number2,
+    title,
+    url,
+    author: toActor(raw["author"]),
+    headBranch,
+    baseBranch,
+    state: toState(raw),
+    isDraft: raw["isDraft"] === true,
+    mergeability: toMergeability(raw["mergeable"]),
+    reviewDecision: toReviewDecision(raw["reviewDecision"]),
+    additions: int(raw["additions"]) ?? 0,
+    deletions: int(raw["deletions"]) ?? 0,
+    createdAt,
+    updatedAt,
+    reviewRequestLogins: toReviewRequestLogins(raw["reviewRequests"]),
+    labels: toLabels(raw["labels"]),
+    checksState: toChecksState(
+      at(nodes(raw["commits"])[0], "commit", "statusCheckRollup", "state")
+    )
+  };
+};
+var decodeSearch = (value) => {
+  const search = asObject2(at(value, "search"));
+  if (search === null) return null;
+  const raw = nodes(search);
+  const items = [];
+  for (const entry of raw) {
+    const node = asObject2(entry);
+    if (node === null) continue;
+    const row = toRow(node);
+    if (row === null) continue;
+    items.push({ ...row, repository: text2(at(node, "repository", "nameWithOwner")) });
+  }
+  return {
+    items,
+    rawCount: raw.length,
+    hasNextPage: at(search, "pageInfo", "hasNextPage") === true
+  };
+};
+var decodeRestPullList = (value) => {
+  if (!Array.isArray(value)) return null;
+  const items = [];
+  for (const entry of value) {
+    const raw = asObject2(entry);
+    if (raw === null) continue;
+    const number2 = int(raw["number"]);
+    const title = text2(raw["title"]);
+    const url = text2(raw["html_url"]);
+    const headBranch = text2(at(raw, "head", "ref"));
+    const baseBranch = text2(at(raw, "base", "ref"));
+    const createdAt = text2(raw["created_at"]);
+    const updatedAt = text2(raw["updated_at"]);
+    if (number2 === null || title === null || url === null || headBranch === null || baseBranch === null || createdAt === null || updatedAt === null) {
+      continue;
+    }
+    const author = asObject2(raw["user"]);
+    const login = text2(author?.["login"]);
+    items.push({
+      number: number2,
+      title,
+      url,
+      author: login === null ? null : { login, name: null, avatarUrl: text2(author?.["avatar_url"]) },
+      headBranch,
+      baseBranch,
+      state: toState({ state: raw["state"], mergedAt: raw["merged_at"] }),
+      isDraft: raw["draft"] === true,
+      mergeability: "unknown",
+      reviewDecision: null,
+      additions: 0,
+      deletions: 0,
+      createdAt,
+      updatedAt,
+      reviewRequestLogins: asArray(raw["requested_reviewers"]).flatMap(
+        (reviewer) => text2(asObject2(reviewer)?.["login"]) ?? []
+      ),
+      labels: asArray(raw["labels"]).flatMap((label) => {
+        const name = text2(asObject2(label)?.["name"]);
+        return name === null ? [] : [{ name, color: text2(asObject2(label)?.["color"]) }];
+      }),
+      checksState: null,
+      hasTeamReviewRequest: asArray(raw["requested_teams"]).length > 0
+    });
+  }
+  return { items, rawCount: value.length };
+};
+var toCanWrite = (value) => {
+  switch (text2(value)?.toUpperCase()) {
+    case "ADMIN":
+    case "MAINTAIN":
+    case "WRITE":
+      return true;
+    default:
+      return false;
+  }
+};
+var toViewerFields = (value) => ({
+  canUpdate: asObject2(value)?.["viewerCanUpdate"] !== false,
+  didAuthor: asObject2(value)?.["viewerDidAuthor"] === true
+});
+var decodeDetail = (value) => {
+  const repository = asObject2(at(value, "repository"));
+  const raw = asObject2(at(repository, "pullRequest"));
+  if (repository === null || raw === null) return null;
+  const row = toRow(raw);
+  if (row === null) return null;
+  const checks = toChecks(
+    nodes(at(nodes(raw["commits"])[0], "commit", "statusCheckRollup", "contexts"))
+  );
+  return {
+    detail: {
+      ...row,
+      // 明细上有逐条检查，汇总就按它自己算，一个字和它下面那张表不会互相打脸。
+      checksState: checksStateFromChecks(checks) ?? row.checksState,
+      body: text2(raw["body"]) === null ? "" : String(raw["body"]),
+      changedFiles: int(raw["changedFiles"]) ?? 0,
+      mergedAt: text2(raw["mergedAt"]),
+      closedAt: text2(raw["closedAt"]),
+      reviewers: nodes(raw["reviewRequests"]).flatMap((node) => {
+        const reviewer = asObject2(at(node, "requestedReviewer"));
+        const login = text2(reviewer?.["login"]) ?? text2(reviewer?.["slug"]);
+        return login === null ? [] : [{ login, name: text2(reviewer?.["name"]), avatarUrl: text2(reviewer?.["avatarUrl"]) }];
+      }),
+      checks,
+      autoMergeEnabled: asObject2(raw["autoMergeRequest"]) !== null
+    },
+    mergeCapabilities: {
+      merge: repository["mergeCommitAllowed"] === true,
+      squash: repository["squashMergeAllowed"] === true,
+      rebase: repository["rebaseMergeAllowed"] === true
+    },
+    access: {
+      canWrite: toCanWrite(repository["viewerPermission"]),
+      ...toViewerFields(raw),
+      canUpdateBranch: raw["viewerCanUpdateBranch"] === true
+    },
+    headRepositoryOwner: text2(at(raw, "headRepositoryOwner", "login"))
+  };
+};
+var decodeViewerAccess = (value) => {
+  const repository = asObject2(at(value, "repository"));
+  if (repository === null) return null;
+  const pullRequest = repository["pullRequest"];
+  return {
+    canWrite: toCanWrite(repository["viewerPermission"]),
+    ...toViewerFields(pullRequest),
+    canUpdateBranch: asObject2(pullRequest)?.["viewerCanUpdateBranch"] === true
+  };
+};
+var decodeBaseComparison = (value) => {
+  const pullRequest = asObject2(at(value, "repository", "pullRequest"));
+  if (pullRequest === null) return null;
+  const behindBy = int(at(pullRequest, "baseRef", "compare", "behindBy"));
+  return {
+    behindBy: behindBy !== null && behindBy >= 0 ? behindBy : null,
+    viewerCanUpdate: pullRequest["viewerCanUpdateBranch"] === true
+  };
+};
+var decodeStats = (value) => {
+  const data = asObject2(value);
+  if (data === null) return null;
+  const stats = /* @__PURE__ */ new Map();
+  for (const [alias, entry] of Object.entries(data)) {
+    const index = /^s(\d+)$/.exec(alias)?.[1];
+    const pullRequest = asObject2(at(entry, "pullRequest"));
+    if (index === void 0 || pullRequest === null) continue;
+    stats.set(Number(index), {
+      additions: int(pullRequest["additions"]) ?? 0,
+      deletions: int(pullRequest["deletions"]) ?? 0
+    });
+  }
+  return stats;
+};
+var isReviewVerdict = (state) => {
+  switch (state?.toUpperCase()) {
+    case "APPROVED":
+    case "CHANGES_REQUESTED":
+    case "DISMISSED":
+      return true;
+    default:
+      return false;
+  }
+};
+var rendersEmpty = (body) => body.replace(/<!--[\s\S]*?-->/g, "").trim().length === 0;
+var toThreadComment = (value, viewer) => {
+  const raw = asObject2(value);
+  const id = text2(raw?.["id"]);
+  const createdAt = text2(raw?.["createdAt"]);
+  if (id === null || createdAt === null) return null;
+  return {
+    id,
+    author: toActor(raw?.["author"]),
+    body: typeof raw?.["body"] === "string" ? raw["body"] : "",
+    createdAt,
+    url: text2(raw?.["url"]),
+    reactions: toReactions(raw?.["reactionGroups"], viewer)
+  };
+};
+var decodeActivity = (value) => {
+  const raw = asObject2(at(value, "repository", "pullRequest"));
+  if (raw === null) return null;
+  const viewer = text2(at(value, "viewer", "login"));
+  const threadPage = raw["reviewThreads"];
+  let threadsTruncated = false;
+  const reviewThreads = [];
+  for (const entry of nodes(threadPage)) {
+    const thread = asObject2(entry);
+    const id = text2(thread?.["id"]);
+    const path2 = text2(thread?.["path"]);
+    const comments2 = nodes(thread?.["comments"]).flatMap(
+      (comment3) => toThreadComment(comment3, viewer) ?? []
+    );
+    if (id === null || path2 === null || comments2.length === 0) continue;
+    if (nextCursorOf(thread?.["comments"]) !== null) threadsTruncated = true;
+    const line = int(thread?.["line"]);
+    reviewThreads.push({
+      id,
+      path: path2,
+      // 线程那一行离开 diff 之后 GitHub 就报 null，那正是它 outdated 的时候。这种线程照列，
+      // 但不再钉在一条它已经没有的行上。
+      line: line !== null && line > 0 ? line : null,
+      side: text2(thread?.["diffSide"])?.toUpperCase() === "LEFT" ? "left" : "right",
+      isResolved: thread?.["isResolved"] === true,
+      isOutdated: thread?.["isOutdated"] === true,
+      comments: comments2
+    });
+  }
+  const dismissals = /* @__PURE__ */ new Map();
+  for (const entry of nodes(raw["reviewDismissals"])) {
+    const reviewId = text2(at(entry, "review", "id"));
+    const message = text2(asObject2(entry)?.["dismissalMessage"]);
+    if (reviewId !== null && message !== null) dismissals.set(reviewId, message);
+  }
+  const issueComments = nodes(raw["comments"]).flatMap(
+    (entry) => {
+      const comment3 = toThreadComment(entry, viewer);
+      return comment3 === null ? [] : [{ ...comment3, kind: "issue-comment", path: null, reviewState: null }];
+    }
+  );
+  const reviews = nodes(raw["reviews"]).flatMap((entry) => {
+    const review = asObject2(entry);
+    const id = text2(review?.["id"]);
+    const submittedAt = text2(review?.["submittedAt"]);
+    const reviewState = text2(review?.["state"]);
+    const body = typeof review?.["body"] === "string" ? review["body"] : "";
+    if (id === null || submittedAt === null) return [];
+    if (body.trim().length === 0 && !isReviewVerdict(reviewState)) return [];
+    return [
+      {
+        id,
+        kind: "review",
+        author: toActor(review?.["author"]),
+        // 撤销的理由写在时间线事件上而不是评审上，所以一条自己看不出话的撤销评审去那里
+        // 取字。是"看不出"而不是"空"：机器人的评审常常只有一个 HTML 标记，markdown 渲染
+        // 出来什么都没有。
+        body: reviewState?.toUpperCase() === "DISMISSED" && rendersEmpty(body) ? dismissals.get(id) ?? body : body,
+        createdAt: submittedAt,
+        url: text2(review?.["url"]),
+        path: null,
+        reviewState,
+        reactions: toReactions(review?.["reactionGroups"], viewer)
+      }
+    ];
+  });
+  const threadComments = reviewThreads.flatMap(
+    (thread) => thread.comments.map(
+      (comment3) => ({
+        id: comment3.id,
+        kind: "review-comment",
+        author: comment3.author,
+        body: comment3.body,
+        createdAt: comment3.createdAt,
+        url: comment3.url,
+        path: thread.path,
+        reviewState: null,
+        reactions: comment3.reactions ?? []
+      })
+    )
+  );
+  const reviewers = /* @__PURE__ */ new Map();
+  for (const entry of [
+    ...nodes(raw["reviewRequests"]).map((node) => at(node, "requestedReviewer")),
+    ...nodes(raw["latestReviews"]).map((node) => at(node, "author"))
+  ]) {
+    const actor = toActor(entry);
+    if (actor !== null && !reviewers.has(actor.login)) reviewers.set(actor.login, actor);
+  }
+  const commits = nodes(raw["commits"]).flatMap((entry) => {
+    const commit = asObject2(at(entry, "commit"));
+    const oid = text2(commit?.["oid"]);
+    const committedDate = text2(commit?.["committedDate"]);
+    if (oid === null || committedDate === null) return [];
+    const additions = int(commit?.["additions"]);
+    const deletions = int(commit?.["deletions"]);
+    return [
+      {
+        oid,
+        messageHeadline: text2(commit?.["messageHeadline"]) ?? "",
+        committedDate,
+        ...additions === null ? {} : { additions: Math.max(0, additions) },
+        ...deletions === null ? {} : { deletions: Math.max(0, deletions) },
+        authors: nodes(commit?.["authors"]).flatMap((author) => toCommitActor(author) ?? [])
+      }
+    ];
+  });
+  const comments = [...issueComments, ...reviews, ...threadComments].toSorted(
+    (left, right) => left.createdAt.localeCompare(right.createdAt)
+  );
+  return {
+    activity: {
+      author: toActor(raw["author"]),
+      reviewers: [...reviewers.values()],
+      reactions: toReactions(raw["reactionGroups"], viewer),
+      comments,
+      commentCount: comments.length,
+      commentsTruncated: threadsTruncated || nextCursorOf(threadPage) !== null || at(raw, "comments", "pageInfo", "hasNextPage") === true || at(raw, "reviews", "pageInfo", "hasNextPage") === true,
+      reviewThreads,
+      commits
+    },
+    nextCursor: nextCursorOf(threadPage)
+  };
+};
+var decodeThreadComments = (value) => {
+  const data = asObject2(value);
+  if (data === null) return null;
+  const viewer = text2(at(data, "viewer", "login"));
+  const expected = text2(at(data, "repository", "pullRequest", "id"));
+  const actual = text2(at(data, "node", "pullRequest", "id"));
+  const comments = at(data, "node", "comments");
+  return {
+    belongsToPullRequest: expected !== null && actual !== null && expected === actual,
+    comments: nodes(comments).flatMap((entry) => toThreadComment(entry, viewer) ?? []),
+    nextCursor: nextCursorOf(comments)
+  };
+};
+var decodeNodeId = (value) => text2(at(value, "repository", "pullRequest", "id"));
+var decodeSubjectScope = (value) => {
+  const expected = text2(at(value, "repository", "pullRequest", "id"));
+  const node = asObject2(at(value, "node"));
+  const actual = node === null ? null : text2(at(node, "pullRequest", "id")) ?? text2(node["id"]);
+  return expected !== null && actual !== null && expected === actual;
+};
+var decodeReviewerCandidates = (value) => {
+  const repository = asObject2(at(value, "repository"));
+  if (repository === null) return null;
+  const pullRequest = repository["pullRequest"];
+  const author = text2(at(pullRequest, "author", "login"));
+  const candidates = /* @__PURE__ */ new Map();
+  for (const entry of nodes(at(pullRequest, "reviewRequests"))) {
+    const raw = asObject2(at(entry, "requestedReviewer"));
+    const isTeam = raw?.["__typename"] === "Team";
+    const id = isTeam ? text2(raw?.["slug"]) : text2(raw?.["login"]);
+    if (id === null) continue;
+    candidates.set(`${isTeam ? "team" : "user"} ${id}`, {
+      id,
+      kind: isTeam ? "team" : "user",
+      login: id,
+      name: text2(raw?.["name"]),
+      avatarUrl: text2(raw?.["avatarUrl"]),
+      isRequested: true
+    });
+  }
+  const assignable = repository["assignableUsers"];
+  for (const entry of nodes(assignable)) {
+    const login = text2(asObject2(entry)?.["login"]);
+    if (login === null || login === author || candidates.has(`user ${login}`)) continue;
+    candidates.set(`user ${login}`, {
+      id: login,
+      kind: "user",
+      login,
+      name: text2(asObject2(entry)?.["name"]),
+      avatarUrl: text2(asObject2(entry)?.["avatarUrl"]),
+      isRequested: false
+    });
+  }
+  return {
+    candidates: [...candidates.values()],
+    truncated: at(assignable, "pageInfo", "hasNextPage") === true
+  };
+};
+var decodeFiles = (value) => {
+  if (!Array.isArray(value)) return null;
+  const sections = [];
+  const omittedFileStats = [];
+  let truncated = false;
+  for (const entry of value) {
+    const raw = asObject2(entry);
+    const filename = text2(raw?.["filename"]);
+    if (filename === null) continue;
+    const hunks = typeof raw?.["patch"] === "string" ? raw["patch"] : "";
+    const status = text2(raw?.["status"])?.toLowerCase();
+    if (hunks.length === 0) {
+      const additions = int(raw?.["additions"]) ?? 0;
+      const deletions = int(raw?.["deletions"]) ?? 0;
+      if (additions + deletions > 0) {
+        truncated = true;
+        omittedFileStats.push({ path: filename, additions, deletions });
+      }
+    }
+    const oldPath = status === "renamed" ? text2(raw?.["previous_filename"]) ?? filename : filename;
+    const header = [
+      `diff --git a/${oldPath} b/${filename}`,
+      // files 端点不报文件模式，用寻常那个顶上：查看器读这两行是"新增"和"删除"，不是读模式。
+      ...status === "added" ? ["new file mode 100644"] : [],
+      ...status === "removed" ? ["deleted file mode 100644"] : [],
+      ...status === "renamed" ? [`rename from ${oldPath}`, `rename to ${filename}`] : [],
+      `--- ${status === "added" ? "/dev/null" : `a/${oldPath}`}`,
+      `+++ ${status === "removed" ? "/dev/null" : `b/${filename}`}`
+    ].join("\n");
+    sections.push(hunks.length === 0 ? `${header}
+` : `${header}
+${hunks.replace(/\n?$/, "\n")}`);
+  }
+  return { patch: sections.join(""), truncated, rawCount: value.length, omittedFileStats };
+};
+var decodeRevisions = (value, kind) => {
+  const raw = asObject2(value);
+  if (raw === null) return null;
+  return kind === "pull-request" ? { baseRef: text2(at(raw, "base", "sha")), headRef: text2(at(raw, "head", "sha")) } : { baseRef: text2(at(asArray(raw["parents"])[0], "sha")), headRef: text2(raw["sha"]) };
+};
+
+// src/githubCommands.ts
+var CAPABILITIES = {
+  diff: true,
+  comment: true,
+  actions: [
+    "merge",
+    "ready",
+    "draft",
+    "close",
+    "reopen",
+    "update-branch",
+    "enable-auto-merge",
+    "disable-auto-merge"
+  ],
+  mergeMethods: ["merge", "squash", "rebase"],
+  updateMethods: ["merge", "rebase"],
+  search: true,
+  reactions: true,
+  review: {
+    inlineComment: true,
+    reply: true,
+    resolve: true,
+    verdicts: ["comment", "approve", "request-changes"]
+  },
+  reviewers: { request: true, listCandidates: true },
+  edit: { changeRequest: true, comment: true }
+};
+var DIFF_MAX_BYTES = 8 * 1024 * 1024;
+var DIFF_TIMEOUT_MS = 6e4;
+var DIFF_FILE_MAX_BYTES = 1024 * 1024;
+var DIFF_FILES_PAGE_SIZE = 100;
+var REVIEW_THREAD_PAGES = 10;
+var FALLBACK_MAX_ROWS = 1e3;
+var REST_PAGE_SIZE = 100;
+var STAT_ALIASES_PER_REQUEST = 25;
+var STAT_REQUEST_CONCURRENCY = 4;
+var gitHubViewerPermissions = (access) => ({
+  actions: [
+    // 布置自动合并与撤销布置就是延后的合并：这里不能合的人，也不该留下一条以后合的指令。
+    ...access.canWrite ? ["merge", "enable-auto-merge", "disable-auto-merge"] : [],
+    ...access.canUpdate ? ["ready", "draft", "close", "reopen"] : [],
+    // 能不能更新分支是 GitHub 自己的答案；答不上来就谁都不给，而不是谁都给。
+    ...access.canUpdateBranch ? ["update-branch"] : []
+  ],
+  comment: true,
+  resolve: access.canWrite || access.didAuthor,
+  // 谁都能评审自己看得见的合并请求，除了自己那条：GitHub 拒绝作者的批准与要求修改
+  // （"Can not approve your own pull request"），只留下评论——那也正是作者对自己改动能说的。
+  verdicts: access.didAuthor ? ["comment"] : CAPABILITIES.review.verdicts,
+  requestReviewers: access.canWrite,
+  ...access.canUpdateBranch ? { updateMethods: CAPABILITIES.updateMethods } : {}
+});
+var failed = (operation, detail) => new GitHubError({ code: "failed", operation, detail });
+var parseRepositorySelector = (value) => {
+  const parts = value.trim().split("/").filter(Boolean);
+  return { name: parts.at(-1) ?? "", owner: parts.at(-2) ?? "" };
+};
+var selector = (input, operation) => {
+  const parsed = parseRepositorySelector(input.repository);
+  if (parsed.owner.length === 0 || parsed.name.length === 0) {
+    throw failed(operation, "A repository was named that GitHub cannot address.");
+  }
+  return parsed;
+};
+var path = (value) => value.split("/").map(encodeURIComponent).join("/");
+var repositoryPath = (input, operation) => {
+  const { owner, name } = selector(input, operation);
+  return `repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}`;
+};
+var diffCursorPage = (cursor) => /^[1-9][0-9]{0,6}$/.test(cursor) ? Number(cursor) : null;
+var isCommitSha = (value) => /^[0-9a-f]{7,64}$/i.test(value);
+var searchPhrase = (query2) => `"${query2.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+var REVIEW_QUALIFIERS = {
+  approved: "approved",
+  "changes-requested": "changes_requested",
+  "review-required": "required",
+  none: "none"
+};
+var qualifierValue = (value) => `"${value.replaceAll('"', "").trim()}"`;
+var resolveAuthor = (author, viewer) => {
+  const trimmed = author.trim();
+  if (!/^@?me$/i.test(trimmed)) return trimmed;
+  return viewer.trim().length === 0 ? trimmed : viewer;
+};
+var filterQualifiers = (filters, viewer) => {
+  if (filters === void 0) return [];
+  return [
+    // 一组一个限定词，组里的名字用逗号连起来——那是 GitHub 自己的"或"。
+    ...(filters.labels ?? []).flatMap(
+      (group) => group.length === 0 ? [] : [`label:${group.map(qualifierValue).join(",")}`]
+    ),
+    ...(filters.excludedLabels ?? []).map((label) => `-label:${qualifierValue(label)}`),
+    ...filters.author === void 0 ? [] : [`author:${qualifierValue(resolveAuthor(filters.author, viewer))}`],
+    ...filters.draft === void 0 ? [] : [`draft:${filters.draft === "only"}`],
+    ...filters.review === void 0 || REVIEW_QUALIFIERS[filters.review] === void 0 ? [] : [`review:${REVIEW_QUALIFIERS[filters.review]}`],
+    ...filters.checks === void 0 ? [] : [`status:${filters.checks === "passing" ? "success" : "failure"}`]
+  ];
+};
+var SEARCH_REPOSITORY = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
+var searchQuery = (input) => {
+  if (input.repositories.length === 0) return null;
+  const repositories = input.repositories.map((repository) => repository.trim());
+  if (!repositories.every((repository) => SEARCH_REPOSITORY.test(repository))) return null;
+  const query2 = input.query?.trim() ?? "";
+  return [
+    "is:pr",
+    // "all" 是所有状态，`is:pr` 本来就是。
+    ...input.state === "open" ? ["is:open"] : [],
+    ...input.state === "closed" ? ["is:closed", "is:unmerged"] : [],
+    ...input.state === "merged" ? ["is:merged"] : [],
+    ...input.involvement === "authored" ? [`author:${input.viewer}`] : [],
+    ...input.involvement === "reviewing" ? [`review-requested:${input.viewer}`] : [],
+    ...query2.length === 0 ? [] : [searchPhrase(query2)],
+    // 上一片结束的那一刻，以及它之前的全部。闭区间：好几行共用一个时刻是常事，问严格更老
+    // 会把其中一些丢掉——调用方自己去掉已经发过的那些。
+    ...input.cursor === void 0 ? [] : [`updated:<=${input.cursor.updatedBefore}`],
+    ...filterQualifiers(input.filters, input.viewer),
+    // 页面读行的次序，也是续读唯一能接上的次序。
+    "sort:updated-desc",
+    ...repositories.map((repository) => `repo:${repository}`)
+  ].join(" ");
+};
+var matchesFallback = (item, input) => {
+  const viewer = input.viewer.toLowerCase();
+  const matchesState = input.state === "all" || item.state === input.state;
+  const matchesInvolvement = input.involvement === "all" || (input.involvement === "authored" ? item.author?.login.toLowerCase() === viewer : item.hasTeamReviewRequest || item.reviewRequestLogins.some((login) => login.toLowerCase() === viewer));
+  const filters = input.filters;
+  if (!matchesState || !matchesInvolvement) return false;
+  if (filters === void 0) return true;
+  const labels = new Set(item.labels.map((label) => label.name.trim().toLowerCase()));
+  const holds = (label) => labels.has(label.trim().toLowerCase());
+  return (filters.draft === void 0 || item.isDraft === (filters.draft === "only")) && (filters.labels === void 0 || filters.labels.every((group) => group.some(holds))) && (filters.excludedLabels === void 0 || !filters.excludedLabels.some(holds)) && (filters.author === void 0 || item.author?.login.toLowerCase() === resolveAuthor(filters.author, input.viewer).toLowerCase());
+};
+var getViewer = async (ctx) => {
+  const login = decodeViewerLogin(
+    await callGitHubJson(ctx, { operation: "getViewer", path: "user" })
+  );
+  if (login === null) {
+    throw failed("getViewer", "GitHub returned no login for the authenticated account.");
+  }
+  return login;
+};
+var searchRows = (limit) => Math.min(limit + 1, SEARCH_MAX_ROWS);
+var listFallback = async (ctx, input) => {
+  const repository = repositoryPath(input, "listChangeRequests");
+  const collected = [];
+  let raw = 0;
+  for (let page = 1; raw < FALLBACK_MAX_ROWS; page += 1) {
+    const decoded = decodeRestPullList(
+      await callGitHubJson(ctx, {
+        operation: "listChangeRequests",
+        host: input.host,
+        path: `${repository}/pulls?state=${input.state === "open" ? "open" : input.state === "all" ? "all" : "closed"}&sort=updated&direction=desc&per_page=${REST_PAGE_SIZE}&page=${page}`
+      })
+    );
+    if (decoded === null) throw readError("listChangeRequests", "pull request list");
+    raw += decoded.rawCount;
+    for (const item of decoded.items) {
+      if (!matchesFallback(item, input)) continue;
+      const { hasTeamReviewRequest: _team, ...row } = item;
+      collected.push(row);
+    }
+    if (collected.length > input.limit) {
+      return { items: collected.slice(0, input.limit), truncated: true, continues: false };
+    }
+    if (decoded.rawCount < REST_PAGE_SIZE) {
+      return { items: collected, truncated: false, continues: false };
+    }
+  }
+  return { items: collected.slice(0, input.limit), truncated: true, continues: false };
+};
+var listChangeRequests = async (ctx, input) => {
+  const query2 = searchQuery({ ...input, repositories: [input.repository] });
+  if (query2 === null) {
+    throw failed("listChangeRequests", "A repository was named that GitHub cannot address.");
+  }
+  const decoded = decodeSearch(
+    await callGitHubGraphQl(ctx, {
+      operation: "listChangeRequests",
+      host: input.host,
+      query: repositorySearchQueryDocument(
+        searchRows(input.limit),
+        await canReadOrg(ctx, input.host)
+      ),
+      variables: { q: query2 }
+    })
+  );
+  if (decoded === null) throw readError("listChangeRequests", "pull request search");
+  const items = decoded.items.slice(0, input.limit).map(({ repository: _repository, ...row }) => row);
+  const hasQuery = (input.query?.trim().length ?? 0) > 0;
+  if (items.length === 0 && input.cursor === void 0 && !hasQuery) {
+    return listFallback(ctx, input);
+  }
+  return {
+    items,
+    truncated: decoded.rawCount > input.limit || decoded.hasNextPage,
+    continues: true
+  };
+};
+var listChangeRequestsAcross = async (ctx, input) => {
+  const query2 = searchQuery(input);
+  if (query2 === null) {
+    throw failed("listChangeRequestsAcross", "A repository was named that GitHub cannot address.");
+  }
+  const decoded = decodeSearch(
+    await callGitHubGraphQl(ctx, {
+      operation: "listChangeRequestsAcross",
+      host: input.host,
+      query: searchQueryDocument(searchRows(input.limit), await canReadOrg(ctx, input.host)),
+      variables: { q: query2 }
+    })
+  );
+  if (decoded === null) throw readError("listChangeRequestsAcross", "pull request search");
+  return {
+    items: decoded.items.slice(0, input.limit).flatMap((row) => row.repository === null ? [] : [{ ...row, repository: row.repository }]),
+    truncated: decoded.rawCount > input.limit || decoded.hasNextPage
+  };
+};
+var listChangeRequestStats = async (ctx, input) => {
+  const chunks = [];
+  for (let start = 0; start < input.changeRequests.length; start += STAT_ALIASES_PER_REQUEST) {
+    chunks.push(input.changeRequests.slice(start, start + STAT_ALIASES_PER_REQUEST));
+  }
+  const read = async (chunk) => {
+    const query2 = buildStatsQuery(chunk);
+    if (query2 === null) {
+      throw failed("listChangeRequestStats", "A repository was named that GitHub cannot address.");
+    }
+    const stats = decodeStats(
+      await callGitHubGraphQl(ctx, {
+        operation: "listChangeRequestStats",
+        host: input.host,
+        query: query2
+      })
+    );
+    if (stats === null) throw readError("listChangeRequestStats", "pull request stats");
+    return chunk.flatMap((changeRequest, index) => {
+      const stat = stats.get(index);
+      return stat === void 0 ? [] : [{ ...changeRequest, ...stat }];
+    });
+  };
+  const results = [];
+  for (let start = 0; start < chunks.length; start += STAT_REQUEST_CONCURRENCY) {
+    const batch = await Promise.all(
+      chunks.slice(start, start + STAT_REQUEST_CONCURRENCY).map(read)
+    );
+    for (const entry of batch) results.push(...entry);
+  }
+  return results;
+};
+var detailOf = async (ctx, input, operation) => {
+  const { owner, name } = selector(input, operation);
+  const decoded = decodeDetail(
+    await callGitHubGraphQl(ctx, {
+      operation,
+      host: input.host,
+      query: detailQueryDocument(await canReadOrg(ctx, input.host)),
+      variables: { owner, name, number: input.number }
+    })
+  );
+  if (decoded === null) throw readError(operation, "pull request detail");
+  return decoded;
+};
+var getChangeRequest = async (ctx, input) => {
+  const { owner, name } = selector(input, "getChangeRequest");
+  const read = await detailOf(ctx, input, "getChangeRequest");
+  const comparison = read.detail.state !== "open" || read.headRepositoryOwner === null ? null : await callGitHubGraphQl(ctx, {
+    operation: "getChangeRequest",
+    host: input.host,
+    query: BASE_COMPARISON_QUERY,
+    variables: {
+      owner,
+      name,
+      number: input.number,
+      headRef: `${read.headRepositoryOwner}:${read.detail.headBranch}`
+    }
+  }).then(decodeBaseComparison).catch(() => null);
+  return {
+    ...read.detail,
+    mergeCapabilities: read.mergeCapabilities,
+    viewerPermissions: gitHubViewerPermissions({
+      ...read.access,
+      canUpdateBranch: comparison?.viewerCanUpdate === true
+    }),
+    baseComparison: comparison === null || comparison.behindBy === null ? "unknown" : comparison.behindBy > 0 ? "behind" : "up-to-date",
+    ...comparison?.behindBy == null ? {} : { behindBy: comparison.behindBy }
+  };
+};
+var getChangeRequestActivity = async (ctx, input) => {
+  const { owner, name } = selector(input, "getChangeRequestActivity");
+  const query2 = activityQueryDocument(await canReadOrg(ctx, input.host));
+  const readPage = async (cursor2) => {
+    const decoded = decodeActivity(
+      await callGitHubGraphQl(ctx, {
+        operation: "getChangeRequestActivity",
+        host: input.host,
+        query: query2,
+        variables: { owner, name, number: input.number, cursor: cursor2 }
+      })
+    );
+    if (decoded === null) throw readError("getChangeRequestActivity", "pull request activity");
+    return decoded;
+  };
+  const first = await readPage(null);
+  const comments = [...first.activity.comments];
+  const reviewThreads = [...first.activity.reviewThreads];
+  let truncated = first.activity.commentsTruncated;
+  let cursor = first.nextCursor;
+  for (let page = 1; cursor !== null && page < REVIEW_THREAD_PAGES; page += 1) {
+    const next = await readPage(cursor);
+    reviewThreads.push(...next.activity.reviewThreads);
+    comments.push(...next.activity.comments.filter((comment3) => comment3.kind === "review-comment"));
+    truncated = truncated || next.activity.commentsTruncated;
+    cursor = next.nextCursor;
+  }
+  const sorted = comments.toSorted((left, right) => left.createdAt.localeCompare(right.createdAt));
+  return {
+    ...first.activity,
+    comments: sorted,
+    commentCount: sorted.length,
+    commentsTruncated: truncated || cursor !== null,
+    reviewThreads
+  };
+};
+var getReviewThreadComments = async (ctx, input) => {
+  const { owner, name } = selector(input, "getReviewThreadComments");
+  const decoded = decodeThreadComments(
+    await callGitHubGraphQl(ctx, {
+      operation: "getReviewThreadComments",
+      host: input.host,
+      query: threadCommentsQueryDocument(await canReadOrg(ctx, input.host)),
+      variables: {
+        owner,
+        name,
+        number: input.number,
+        threadId: input.threadId,
+        cursor: input.cursor
+      }
+    })
+  );
+  if (decoded === null) throw readError("getReviewThreadComments", "review thread");
+  if (!decoded.belongsToPullRequest) {
+    throw failed(
+      "getReviewThreadComments",
+      "The named subject did not belong to the named pull request."
+    );
+  }
+  return { comments: decoded.comments, nextCursor: decoded.nextCursor };
+};
+var getViewerPermissions = async (ctx, input) => {
+  const { owner, name } = selector(input, "getViewerPermissions");
+  const access = decodeViewerAccess(
+    await callGitHubGraphQl(ctx, {
+      operation: "getViewerPermissions",
+      host: input.host,
+      query: VIEWER_PERMISSIONS_QUERY,
+      variables: { owner, name, number: input.number }
+    })
+  );
+  if (access === null) throw readError("getViewerPermissions", "viewer permissions");
+  return gitHubViewerPermissions(access);
+};
+var diffFilesPage = async (ctx, input) => {
+  const repository = repositoryPath(input, "getDiff");
+  const paging = `per_page=${DIFF_FILES_PAGE_SIZE}&page=${input.page}`;
+  const result = await callGitHubApi(ctx, {
+    operation: "getDiff",
+    host: input.host,
+    path: input.commit === void 0 ? `${repository}/pulls/${input.number}/files?${paging}` : `${repository}/commits/${input.commit}?${paging}`,
+    maxBytes: DIFF_MAX_BYTES,
+    timeoutMs: DIFF_TIMEOUT_MS
+  });
+  if (result.truncated) {
+    throw failed("getDiff", `Page ${input.page} of the changed files was too large to read.`);
+  }
+  let body;
+  try {
+    body = JSON.parse(result.body.trim());
+  } catch {
+    throw readError("getDiff", "changed files");
+  }
+  const files = input.commit === void 0 ? body : body?.files ?? [];
+  const decoded = decodeFiles(files);
+  if (decoded === null) throw readError("getDiff", "changed files");
+  const morePages = decoded.rawCount >= DIFF_FILES_PAGE_SIZE;
+  return {
+    patch: decoded.patch,
+    truncated: decoded.truncated,
+    nextCursor: morePages ? String(input.page + 1) : null,
+    ...decoded.omittedFileStats.length === 0 ? {} : { omittedFileStats: decoded.omittedFileStats }
+  };
+};
+var getDiff = async (ctx, input) => {
+  if (input.commit !== void 0 && !isCommitSha(input.commit)) {
+    throw failed("getDiff", "The named commit was not a commit sha.");
+  }
+  const target = {
+    cwd: input.cwd,
+    repository: input.repository,
+    host: input.host,
+    number: input.number,
+    ...input.commit === void 0 ? {} : { commit: input.commit }
+  };
+  if (input.cursor !== void 0) {
+    const page = diffCursorPage(input.cursor);
+    if (page === null) {
+      throw failed("getDiff", "The diff cursor was not one this pull request handed out.");
+    }
+    return diffFilesPage(ctx, { ...target, page });
+  }
+  if (input.commit !== void 0) return diffFilesPage(ctx, { ...target, page: 1 });
+  const whole = async () => {
+    const result = await callGitHubApi(ctx, {
+      operation: "getDiff",
+      host: input.host,
+      path: `${repositoryPath(input, "getDiff")}/pulls/${input.number}`,
+      accept: "application/vnd.github.diff",
+      maxBytes: DIFF_MAX_BYTES,
+      timeoutMs: DIFF_TIMEOUT_MS
+    });
+    return result.truncated ? null : { patch: result.body, truncated: false, nextCursor: null };
+  };
+  try {
+    const slice = await whole();
+    return slice ?? await diffFilesPage(ctx, { ...target, page: 1 });
+  } catch (error) {
+    if (error instanceof GitHubError && error.code !== "failed") throw error;
+    try {
+      return await diffFilesPage(ctx, { ...target, page: 1 });
+    } catch {
+      throw error;
+    }
+  }
+};
+var getDiffFileContents = async (ctx, input) => {
+  const operation = "getDiffFileContents";
+  if (input.commit !== void 0 && !isCommitSha(input.commit)) {
+    throw failed(operation, "The named commit was not a commit sha.");
+  }
+  const repository = repositoryPath(input, operation);
+  const revisions = decodeRevisions(
+    await callGitHubJson(ctx, {
+      operation,
+      host: input.host,
+      path: input.commit === void 0 ? `${repository}/pulls/${input.number}` : `${repository}/commits/${input.commit}`,
+      maxBytes: DIFF_MAX_BYTES,
+      timeoutMs: DIFF_TIMEOUT_MS
+    }),
+    input.commit === void 0 ? "pull-request" : "commit"
+  );
+  const rootCommitNewFile = input.commit !== void 0 && input.changeType === "new" && revisions?.baseRef === null;
+  const baseRef = revisions?.baseRef ?? null;
+  const headRef = revisions?.headRef ?? null;
+  if (headRef === null || !isCommitSha(headRef) || !rootCommitNewFile && (baseRef === null || !isCommitSha(baseRef))) {
+    throw failed(
+      operation,
+      input.commit === void 0 ? `Pull request #${input.number} reported no usable base and head revisions.` : `Commit ${input.commit} reported no usable revisions for this file.`
+    );
+  }
+  const readFile = async (revision, filePath) => {
+    const result = await callGitHubApi(ctx, {
+      operation,
+      host: input.host,
+      path: `${repository}/contents/${path(filePath)}?ref=${encodeURIComponent(revision)}`,
+      accept: "application/vnd.github.raw",
+      maxBytes: DIFF_FILE_MAX_BYTES,
+      timeoutMs: DIFF_TIMEOUT_MS
+    });
+    if (result.truncated) {
+      throw failed(operation, `The diff file '${filePath}' exceeds the 1 MB expansion limit.`);
+    }
+    if (result.body.includes("\0")) {
+      throw failed(operation, `The diff file '${filePath}' is binary.`);
+    }
+    return result.body;
+  };
+  const [oldContents, newContents] = await Promise.all([
+    input.changeType === "new" ? Promise.resolve("") : readFile(baseRef, input.oldPath),
+    input.changeType === "deleted" ? Promise.resolve("") : readFile(headRef, input.newPath)
+  ]);
+  return { oldContents, newContents };
+};
+var listReviewerCandidates = async (ctx, input) => {
+  const { owner, name } = selector(input, "listReviewerCandidates");
+  const decoded = decodeReviewerCandidates(
+    await callGitHubGraphQl(ctx, {
+      operation: "listReviewerCandidates",
+      host: input.host,
+      query: reviewerCandidatesQueryDocument(await canReadOrg(ctx, input.host)),
+      variables: { owner, name, number: input.number }
+    })
+  );
+  if (decoded === null) throw readError("listReviewerCandidates", "reviewer candidates");
+  return decoded;
+};
+var pullRequestNodeId = async (ctx, input, operation) => {
+  const { owner, name } = selector(input, operation);
+  const id = decodeNodeId(
+    await callGitHubGraphQl(ctx, {
+      operation,
+      host: input.host,
+      query: NODE_ID_QUERY,
+      variables: { owner, name, number: input.number }
+    })
+  );
+  if (id === null) throw readError(operation, "pull request id");
+  return id;
+};
+var requireSubjectScope = async (ctx, input, operation) => {
+  const { owner, name } = selector(input, operation);
+  const belongs = decodeSubjectScope(
+    await callGitHubGraphQl(ctx, {
+      operation,
+      host: input.host,
+      query: SUBJECT_SCOPE_QUERY,
+      variables: { owner, name, number: input.number, subjectId: input.subjectId }
+    })
+  );
+  if (!belongs) {
+    throw failed(operation, "The named subject did not belong to the named pull request.");
+  }
+  return input.subjectId;
+};
+var setReviewerRequest = async (ctx, input) => {
+  await callGitHubApi(ctx, {
+    operation: "setReviewerRequest",
+    host: input.host,
+    path: `${repositoryPath(input, "setReviewerRequest")}/pulls/${input.number}/requested_reviewers`,
+    method: input.requested ? "POST" : "DELETE",
+    body: JSON.stringify({
+      reviewers: input.reviewers.flatMap(
+        (reviewer) => reviewer.kind === "user" ? [reviewer.id] : []
+      ),
+      team_reviewers: input.reviewers.flatMap(
+        (reviewer) => reviewer.kind === "team" ? [reviewer.id] : []
+      )
+    })
+  });
+  return null;
+};
+var runAction = async (ctx, input) => {
+  const repository = repositoryPath(input, "runAction");
+  const mutate = async (query2, variables) => {
+    const pullRequestId = await pullRequestNodeId(ctx, input, "runAction");
+    await callGitHubGraphQl(ctx, {
+      operation: "runAction",
+      host: input.host,
+      query: query2,
+      variables: { pullRequestId, ...variables }
+    });
+  };
+  switch (input.action) {
+    case "merge":
+      await callGitHubApi(ctx, {
+        operation: "runAction",
+        host: input.host,
+        path: `${repository}/pulls/${input.number}/merge`,
+        method: "PUT",
+        body: JSON.stringify({ merge_method: input.mergeMethod ?? "merge" })
+      });
+      return null;
+    // 布置自动合并仍然要带策略：GitHub 把策略跟那条待办指令存在一起，而不是到合并那一刻
+    // 再挑一个。
+    case "enable-auto-merge":
+      await mutate(ENABLE_AUTO_MERGE_MUTATION, {
+        mergeMethod: (input.mergeMethod ?? "merge").toUpperCase()
+      });
+      return null;
+    case "disable-auto-merge":
+      await mutate(DISABLE_AUTO_MERGE_MUTATION, {});
+      return null;
+    // REST 的 update-branch 端点只会用合并提交更新，rebase 那一半只有 GraphQL 有。
+    case "update-branch":
+      await mutate(UPDATE_BRANCH_MUTATION, {
+        updateMethod: input.updateMethod === "rebase" ? "REBASE" : "MERGE"
+      });
+      return null;
+    case "ready":
+      await mutate(READY_MUTATION, {});
+      return null;
+    case "draft":
+      await mutate(DRAFT_MUTATION, {});
+      return null;
+    case "close":
+    case "reopen":
+      await callGitHubApi(ctx, {
+        operation: "runAction",
+        host: input.host,
+        path: `${repository}/pulls/${input.number}`,
+        method: "PATCH",
+        body: JSON.stringify({ state: input.action === "close" ? "closed" : "open" })
+      });
+      return null;
+  }
+};
+var updateChangeRequest = async (ctx, input) => {
+  await callGitHubApi(ctx, {
+    operation: "updateChangeRequest",
+    host: input.host,
+    path: `${repositoryPath(input, "updateChangeRequest")}/pulls/${input.number}`,
+    method: "PATCH",
+    // 调用方没点名的字段整个不发，GitHub 就把已有的字留着，而不是被要求写一个空的。
+    body: JSON.stringify({
+      ...input.title === void 0 ? {} : { title: input.title },
+      ...input.body === void 0 ? {} : { body: input.body }
+    })
+  });
+  return null;
+};
+var comment = async (ctx, input) => {
+  await callGitHubApi(ctx, {
+    operation: "comment",
+    host: input.host,
+    path: `${repositoryPath(input, "comment")}/issues/${input.number}/comments`,
+    method: "POST",
+    body: JSON.stringify({ body: input.body })
+  });
+  return null;
+};
+var updateComment = async (ctx, input) => {
+  const commentId = await requireSubjectScope(
+    ctx,
+    { ...input, subjectId: input.commentId },
+    "updateComment"
+  );
+  await callGitHubGraphQl(ctx, {
+    operation: "updateComment",
+    host: input.host,
+    query: input.kind === "review-comment" ? UPDATE_REVIEW_COMMENT_MUTATION : UPDATE_ISSUE_COMMENT_MUTATION,
+    variables: { commentId, body: input.body }
+  });
+  return null;
+};
+var submitReview = async (ctx, input) => {
+  await callGitHubApi(ctx, {
+    operation: "submitReview",
+    host: input.host,
+    path: `${repositoryPath(input, "submitReview")}/pulls/${input.number}/reviews`,
+    method: "POST",
+    body: JSON.stringify({
+      event: REVIEW_EVENT_BY_VERDICT[input.verdict],
+      body: input.body,
+      comments: input.comments.map((draft) => ({
+        path: draft.path,
+        ...gitHubReviewPosition(draft.position),
+        body: draft.body
+      }))
+    })
+  });
+  return null;
+};
+var replyToThread = async (ctx, input) => {
+  await callGitHubGraphQl(ctx, {
+    operation: "replyToThread",
+    host: input.host,
+    query: REPLY_MUTATION,
+    variables: { threadId: input.threadId, body: input.body }
+  });
+  return null;
+};
+var setThreadResolution = async (ctx, input) => {
+  await callGitHubGraphQl(ctx, {
+    operation: "setThreadResolution",
+    host: input.host,
+    query: input.resolved ? RESOLVE_MUTATION : UNRESOLVE_MUTATION,
+    variables: { threadId: input.threadId }
+  });
+  return null;
+};
+var setReaction = async (ctx, input) => {
+  const subjectId = input.subjectId === void 0 ? await pullRequestNodeId(ctx, input, "setReaction") : await requireSubjectScope(ctx, { ...input, subjectId: input.subjectId }, "setReaction");
+  await callGitHubGraphQl(ctx, {
+    operation: "setReaction",
+    host: input.host,
+    query: input.reacted ? ADD_REACTION_MUTATION : REMOVE_REACTION_MUTATION,
+    variables: { subjectId, content: gitHubReactionContent(input.content) }
+  });
+  return null;
+};
+
+// src/gitlabHttp.ts
+var DEFAULT_TIMEOUT_MS2 = 3e4;
+var DEFAULT_MAX_BYTES2 = 1024 * 1024;
+var DEFAULT_HOST2 = "gitlab.com";
+var CARD2 = "Settings \u2192 Plugins \u2192 Pull requests";
+var GitLabError = class extends Error {
+  code;
+  constructor(input) {
+    super(`GitLab API failed in ${input.operation}: ${input.detail}`);
+    this.name = "GitLabError";
+    this.code = input.code;
+  }
+};
+var text3 = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+var normalizeHost2 = (value) => value.trim().replace(/^https?:\/\//i, "").replace(/\/+$/, "").toLowerCase();
+var configuredHost2 = (ctx) => normalizeHost2(text3(ctx.config["gitlabHost"]) ?? DEFAULT_HOST2);
+var configuredToken2 = (ctx) => text3(ctx.config["gitlabToken"]);
+var readBody2 = async (response, maxBytes) => {
+  const stream = response.body;
+  if (stream === null) return { body: "", truncated: false };
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let body = "";
+  let read = 0;
+  for (; ; ) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    const value = chunk.value;
+    if (value === void 0) continue;
+    if (read + value.byteLength > maxBytes) {
+      body += decoder.decode(value.subarray(0, maxBytes - read), { stream: true });
+      await reader.cancel();
+      return { body, truncated: true };
+    }
+    read += value.byteLength;
+    body += decoder.decode(value, { stream: true });
+  }
+  return { body: body + decoder.decode(), truncated: false };
+};
+var statusError2 = (input) => {
+  if (input.status === 401 || input.status === 403) {
+    return new GitLabError({
+      code: "unauthenticated",
+      operation: input.operation,
+      detail: `GitLab refused the token (HTTP ${input.status}). Check the token and its \`api\` scope in ${CARD2}.`
+    });
+  }
+  if (input.status === 429) {
+    return new GitLabError({
+      code: "rate-limited",
+      operation: input.operation,
+      detail: input.retryAfter === null ? "GitLab API rate limit exceeded." : `GitLab API rate limit exceeded; retry after ${input.retryAfter}s.`
+    });
+  }
+  return new GitLabError({
+    code: "failed",
+    operation: input.operation,
+    detail: `GitLab answered HTTP ${input.status}.`
+  });
+};
+var requestError2 = (operation, error) => {
+  const name = error instanceof Error ? error.name : "";
+  if (name === "TimeoutError" || name === "AbortError") {
+    return new GitLabError({
+      code: "failed",
+      operation,
+      detail: "GitLab did not answer before the timeout."
+    });
+  }
+  return new GitLabError({
+    code: "failed",
+    operation,
+    detail: error instanceof Error ? error.message : String(error)
+  });
+};
+var send2 = async (ctx, input) => {
+  const host = configuredHost2(ctx);
+  const asked = input.host === void 0 ? null : normalizeHost2(input.host);
+  if (asked !== null && asked.length > 0 && asked !== host) {
+    throw new GitLabError({
+      code: "unauthenticated",
+      operation: input.operation,
+      detail: `This repository lives on ${asked}, but ${CARD2} is configured for ${host}.`
+    });
+  }
+  const token = configuredToken2(ctx);
+  if (token === null) {
+    throw new GitLabError({
+      code: "missing-tool",
+      operation: input.operation,
+      detail: `No GitLab token is configured. Add a personal access token with the \`api\` scope in ${CARD2}.`
+    });
+  }
+  let response;
+  try {
+    response = await ctx.http(input.url(`https://${host}`), {
+      method: input.method ?? "GET",
+      headers: { "PRIVATE-TOKEN": token, "Content-Type": "application/json" },
+      ...input.body === void 0 ? {} : { body: input.body },
+      signal: AbortSignal.timeout(input.timeoutMs ?? DEFAULT_TIMEOUT_MS2)
+    });
+  } catch (error) {
+    throw requestError2(input.operation, error);
+  }
+  if (!response.ok) {
+    await response.body?.cancel();
+    throw statusError2({
+      operation: input.operation,
+      status: response.status,
+      retryAfter: response.headers.get("Retry-After")
+    });
+  }
+  try {
+    return await readBody2(response, input.maxBytes ?? DEFAULT_MAX_BYTES2);
+  } catch (error) {
+    throw requestError2(input.operation, error);
+  }
+};
+var callGitLabApi = (ctx, input) => send2(ctx, { ...input, url: (base) => `${base}/api/v4/${input.path}` });
+var callGitLabGraphQl = (ctx, input) => send2(ctx, { ...input, url: (base) => `${base}/api/graphql`, method: "POST" });
+var readError2 = (operation, what) => new GitLabError({
+  code: "failed",
+  operation,
+  detail: `GitLab returned an unreadable ${what} response.`
+});
+
+// src/gitlabMapping.ts
+var asObject3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+var asArray2 = (value) => Array.isArray(value) ? value : null;
+var text4 = (value) => {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+};
+var rawText = (value) => typeof value === "string" ? value : null;
+var int2 = (value) => typeof value === "number" && Number.isInteger(value) ? value : null;
+var bool = (value) => typeof value === "boolean" ? value : null;
+var parseJson = (raw) => {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+};
+var toActor2 = (value) => {
+  const raw = asObject3(value);
+  const login = text4(raw?.username);
+  return login === null ? null : { login, name: text4(raw?.name), avatarUrl: text4(raw?.avatar_url) };
+};
+var toLabels2 = (value) => (asArray2(value) ?? []).flatMap((entry) => {
+  const name = text4(entry);
+  return name === null ? [] : [{ name, color: null }];
+});
+var toPipelineStatus = (value) => {
+  switch (text4(value)?.toLowerCase()) {
+    case "success":
+      return "success";
+    case "failed":
+      return "failure";
+    case "canceled":
+    case "cancelling":
+      return "cancelled";
+    case "skipped":
+      return "skipped";
+    // 等人点一下的流水线既不是进度也不是失败。
+    case "manual":
+    case "scheduled":
+      return "neutral";
+    default:
+      return "pending";
+  }
+};
+var toChecks2 = (raw) => {
+  const pipeline = asObject3(raw.head_pipeline);
+  if (pipeline === null) return [];
+  return [
+    {
+      name: "Pipeline",
+      status: toPipelineStatus(pipeline.status),
+      description: text4(pipeline.source),
+      url: text4(pipeline.web_url)
+    }
+  ];
+};
+var toState2 = (raw) => {
+  if (text4(raw.merged_at) !== null) return "merged";
+  switch (text4(raw.state)?.toLowerCase()) {
+    case "merged":
+      return "merged";
+    case "closed":
+      return "closed";
+    default:
+      return "open";
+  }
+};
+var toMergeability2 = (raw) => {
+  if (bool(raw.has_conflicts) === true) return "conflicting";
+  switch (text4(raw.merge_status)?.toLowerCase()) {
+    case "can_be_merged":
+      return "mergeable";
+    case "cannot_be_merged":
+      return "conflicting";
+    default:
+      return "unknown";
+  }
+};
+var toChangedFiles = (value) => {
+  const parsed = Number.parseInt(text4(value) ?? "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+};
+var toListItem = (value) => {
+  const raw = asObject3(value);
+  if (raw === null) return null;
+  const number2 = int2(raw.iid);
+  const title = rawText(raw.title);
+  const url = rawText(raw.web_url);
+  const headBranch = rawText(raw.source_branch);
+  const baseBranch = rawText(raw.target_branch);
+  const createdAt = rawText(raw.created_at);
+  const updatedAt = rawText(raw.updated_at);
+  if (number2 === null || title === null || url === null || headBranch === null || baseBranch === null || createdAt === null || updatedAt === null) {
+    return null;
+  }
+  return {
+    number: number2,
+    title,
+    url,
+    author: toActor2(raw.author),
+    headBranch,
+    baseBranch,
+    state: toState2(raw),
+    isDraft: bool(raw.draft) ?? bool(raw.work_in_progress) ?? false,
+    mergeability: toMergeability2(raw),
+    additions: 0,
+    deletions: 0,
+    createdAt,
+    updatedAt,
+    reviewRequestLogins: (asArray2(raw.reviewers) ?? []).flatMap((reviewer) => {
+      const login = text4(asObject3(reviewer)?.username);
+      return login === null ? [] : [login];
+    }),
+    labels: toLabels2(raw.labels)
+  };
+};
+var decodeMergeRequestDetail = (raw) => {
+  const parsed = asObject3(parseJson(raw));
+  if (parsed === null) return null;
+  const listItem = toListItem(parsed);
+  if (listItem === null) return null;
+  const pipelineAutoMerge = bool(parsed.merge_when_pipeline_succeeds);
+  const namedAutoMerge = bool(parsed.auto_merge_enabled);
+  const autoMerge = pipelineAutoMerge === null && namedAutoMerge === null ? void 0 : pipelineAutoMerge === true || namedAutoMerge === true;
+  const diverged = int2(parsed.diverged_commits_count);
+  const reviewers = asArray2(parsed.reviewers) ?? [];
+  return {
+    ...listItem,
+    body: rawText(parsed.description) ?? "",
+    changedFiles: toChangedFiles(parsed.changes_count),
+    mergedAt: text4(parsed.merged_at),
+    closedAt: text4(parsed.closed_at),
+    // 从 reviewer 对象本身建，头像才不会丢。
+    reviewers: reviewers.flatMap((reviewer) => {
+      const actor = toActor2(reviewer);
+      return actor === null ? [] : [actor];
+    }),
+    checks: toChecks2(parsed),
+    viewerCanMerge: bool(asObject3(parsed.user)?.can_merge) !== false,
+    reviewerIds: reviewers.flatMap((reviewer) => {
+      const id = int2(asObject3(reviewer)?.id);
+      return id === null ? [] : [id];
+    }),
+    ...autoMerge === void 0 ? {} : { autoMergeEnabled: autoMerge },
+    ...diverged === null ? {} : { divergedCommits: diverged }
+  };
+};
+var decodeMergeRequestList = (raw) => {
+  const entries = asArray2(parseJson(raw));
+  if (entries === null) return null;
+  const items = [];
+  const rawIndexes = [];
+  for (const [rawIndex, entry] of entries.entries()) {
+    const item = toListItem(entry);
+    if (item === null) continue;
+    items.push(item);
+    rawIndexes.push(rawIndex);
+  }
+  return { items, rawIndexes, rawCount: entries.length };
+};
+var decodeViewer = (raw) => {
+  const parsed = asObject3(parseJson(raw));
+  return parsed === null ? null : { username: text4(parsed.username) };
+};
+var decodeProjectUsers = (raw) => {
+  const entries = asArray2(parseJson(raw));
+  if (entries === null) return null;
+  const candidates = [];
+  for (const entry of entries) {
+    const id = int2(asObject3(entry)?.id);
+    if (id === null) continue;
+    const actor = toActor2(entry);
+    if (actor === null) continue;
+    candidates.push({ ...actor, id: String(id), kind: "user", isRequested: false });
+  }
+  return { candidates, rawCount: entries.length };
+};
+var decodeProjectMergeCapabilities = (raw) => {
+  const parsed = asObject3(parseJson(raw));
+  if (parsed === null) return null;
+  const mergeMethod = text4(parsed.merge_method)?.toLowerCase();
+  const squashOption = text4(parsed.squash_option)?.toLowerCase();
+  return {
+    merge: mergeMethod === "merge",
+    // 半线性与 fast-forward 两种历史都是把分支 rebase 到目标上得到的。
+    rebase: mergeMethod === "rebase_merge" || mergeMethod === "ff",
+    squash: squashOption === "always" || squashOption === "default_on" || squashOption === "default_off"
+  };
+};
+var decodeNotes = (raw) => {
+  const entries = asArray2(parseJson(raw));
+  if (entries === null) return null;
+  const comments = [];
+  for (const entry of entries) {
+    const note = asObject3(entry);
+    const id = int2(note?.id);
+    const createdAt = rawText(note?.created_at);
+    if (note === null || id === null || createdAt === null) continue;
+    if (bool(note.system) === true) continue;
+    const body = rawText(note.body) ?? "";
+    if (body.trim().length === 0) continue;
+    const position = asObject3(note.position);
+    comments.push({
+      id: String(id),
+      kind: text4(note.type) === "DiffNote" ? "review-comment" : "issue-comment",
+      author: toActor2(note.author),
+      body,
+      createdAt,
+      url: null,
+      path: text4(position?.new_path) ?? text4(position?.old_path),
+      reviewState: null
+    });
+  }
+  return { comments, rawCount: entries.length };
+};
+var decodeDiscussions = (raw) => {
+  const entries = asArray2(parseJson(raw));
+  if (entries === null) return null;
+  const threads = [];
+  for (const entry of entries) {
+    const discussion = asObject3(entry);
+    const id = text4(discussion?.id);
+    if (discussion === null || id === null) continue;
+    const notes = (asArray2(discussion.notes) ?? []).flatMap((value) => {
+      const note = asObject3(value);
+      if (note === null || bool(note.system) === true) return [];
+      const noteId = int2(note.id);
+      const createdAt = rawText(note.created_at);
+      return noteId === null || createdAt === null ? [] : [{ note, noteId, createdAt }];
+    });
+    const root = notes[0];
+    const position = asObject3(root?.note.position);
+    if (root === void 0 || position === null || text4(position.position_type) !== "text") {
+      continue;
+    }
+    const newLine = int2(position.new_line);
+    const side = newLine === null ? "left" : "right";
+    const path2 = text4(side === "left" ? position.old_path : position.new_path);
+    if (path2 === null) continue;
+    const line = side === "left" ? int2(position.old_line) : newLine;
+    threads.push({
+      id,
+      path: path2,
+      line: line !== null && line > 0 ? line : null,
+      side,
+      isResolved: bool(root.note.resolved) === true,
+      // GitLab 不报「写在一条已经挪走的行上」，diff 放不下的线程由 diff 自己算，
+      // 不在这里声称。
+      isOutdated: false,
+      comments: notes.map(
+        ({ note, noteId, createdAt }) => ({
+          id: String(noteId),
+          author: toActor2(note.author),
+          body: rawText(note.body) ?? "",
+          createdAt,
+          url: null
+        })
+      )
+    });
+  }
+  return { threads, rawCount: entries.length };
+};
+var decodeCommits = (raw) => {
+  const entries = asArray2(parseJson(raw));
+  if (entries === null) return null;
+  const commits = [];
+  for (const entry of entries) {
+    const commit = asObject3(entry);
+    const oid = text4(commit?.id);
+    if (commit === null || oid === null) continue;
+    const committedDate = text4(commit.committed_date) ?? text4(commit.created_at);
+    if (committedDate === null) continue;
+    const stats = asObject3(commit.stats);
+    const login = text4(commit.author_name) ?? text4(commit.author_email);
+    commits.push({
+      oid,
+      messageHeadline: rawText(commit.title) ?? "",
+      committedDate,
+      ...stats === null ? {} : {
+        additions: Math.max(0, int2(stats.additions) ?? 0),
+        deletions: Math.max(0, int2(stats.deletions) ?? 0)
+      },
+      authors: login === null ? [] : [{ login, name: text4(commit.author_name), avatarUrl: null }]
+    });
+  }
+  return commits.toReversed();
+};
+var decodeDiffRefs = (raw) => {
+  const parsed = asObject3(parseJson(raw));
+  if (parsed === null) return null;
+  const refs = asObject3(parsed.diff_refs);
+  if (refs === null) return { refs: null };
+  const baseSha = rawText(refs.base_sha);
+  const headSha = rawText(refs.head_sha);
+  const startSha = rawText(refs.start_sha);
+  if (baseSha === null || headSha === null || startSha === null) return null;
+  return { refs: { baseSha, headSha, startSha } };
+};
+var decodeMergeRequestDiffs = (raw) => {
+  const entries = asArray2(parseJson(raw));
+  if (entries === null) return null;
+  const sections = [];
+  let truncated = false;
+  for (const entry of entries) {
+    const file = asObject3(entry);
+    const oldPath = rawText(file?.old_path);
+    const newPath = rawText(file?.new_path);
+    if (file === null || oldPath === null || newPath === null) continue;
+    const hunks = rawText(file.diff) ?? "";
+    const isNew = bool(file.new_file) === true;
+    const isDeleted = bool(file.deleted_file) === true;
+    if (hunks.length === 0) {
+      truncated = truncated || bool(file.too_large) === true || bool(file.collapsed) === true;
+    }
+    const header = [
+      `diff --git a/${oldPath} b/${newPath}`,
+      ...isNew ? [`new file mode ${rawText(file.b_mode) ?? "100644"}`] : [],
+      ...isDeleted ? [`deleted file mode ${rawText(file.a_mode) ?? "100644"}`] : [],
+      ...bool(file.renamed_file) === true ? [`rename from ${oldPath}`, `rename to ${newPath}`] : [],
+      `--- ${isNew ? "/dev/null" : `a/${oldPath}`}`,
+      `+++ ${isDeleted ? "/dev/null" : `b/${newPath}`}`
+    ].join("\n");
+    sections.push(hunks.length === 0 ? header : `${header}
+${hunks.replace(/\n?$/, "\n")}`);
+  }
+  return { patch: sections.join("\n"), truncated, rawCount: entries.length };
+};
+var GITLAB_AWARD_BY_CONTENT = {
+  "thumbs-up": "thumbsup",
+  "thumbs-down": "thumbsdown",
+  laugh: "laughing",
+  hooray: "tada",
+  confused: "confused",
+  heart: "heart",
+  rocket: "rocket",
+  eyes: "eyes"
+};
+var CONTENT_BY_GITLAB_AWARD = Object.fromEntries(
+  Object.entries(GITLAB_AWARD_BY_CONTENT).map(([content, name]) => [name, content])
+);
+var gitLabAwardName = (content) => GITLAB_AWARD_BY_CONTENT[content];
+var AWARD_EMOJI_GRAPHQL_QUERY = `query($fullPath: ID!, $iid: String!, $cursor: String) {
+  currentUser { username }
+  project(fullPath: $fullPath) {
+    mergeRequest(iid: $iid) {
+      awardEmoji { nodes { name user { username } } }
+      notes(first: 100, after: $cursor) {
+        pageInfo { hasNextPage endCursor }
+        nodes { id awardEmoji { nodes { name user { username } } } }
+      }
+    }
+  }
+}`;
+var toReactions2 = (value, viewer) => {
+  const normalizedViewer = viewer?.toLowerCase() ?? null;
+  const groups = /* @__PURE__ */ new Map();
+  for (const node of asArray2(asObject3(value)?.nodes) ?? []) {
+    const content = CONTENT_BY_GITLAB_AWARD[text4(asObject3(node)?.name)?.toLowerCase() ?? ""];
+    if (content === void 0) continue;
+    const username = text4(asObject3(asObject3(node)?.user)?.username);
+    if (username === null) continue;
+    const group = groups.get(content) ?? { count: 0, actors: [], viewer: false };
+    group.count++;
+    if (normalizedViewer !== null && username.toLowerCase() === normalizedViewer) {
+      group.viewer = true;
+    } else {
+      group.actors.push(username);
+    }
+    groups.set(content, group);
+  }
+  return [...groups].flatMap(
+    ([content, group]) => group.count === 0 ? [] : [{ content, count: group.count, actors: group.actors, viewerHasReacted: group.viewer }]
+  );
+};
+var noteIdOf = (value) => {
+  const id = text4(value)?.split("/").at(-1);
+  return id !== void 0 && /^\d+$/.test(id) ? id : null;
+};
+var decodeAwardEmoji = (raw) => {
+  const data = asObject3(asObject3(parseJson(raw))?.data);
+  if (data === null) return null;
+  const viewer = text4(asObject3(data.currentUser)?.username);
+  const mergeRequest = asObject3(asObject3(data.project)?.mergeRequest);
+  const notes = asObject3(mergeRequest?.notes);
+  const reactionsByNoteId = /* @__PURE__ */ new Map();
+  for (const node of asArray2(notes?.nodes) ?? []) {
+    const id = noteIdOf(asObject3(node)?.id);
+    if (id === null) continue;
+    const reactions = toReactions2(asObject3(node)?.awardEmoji, viewer);
+    if (reactions.length > 0) reactionsByNoteId.set(id, reactions);
+  }
+  const pageInfo = asObject3(notes?.pageInfo);
+  return {
+    reactions: toReactions2(mergeRequest?.awardEmoji, viewer),
+    reactionsByNoteId,
+    nextCursor: bool(pageInfo?.hasNextPage) === true ? text4(pageInfo?.endCursor) : null
+  };
+};
+var decodeOwnAwardId = (raw, input) => {
+  const entries = asArray2(parseJson(raw));
+  if (entries === null) return null;
+  const name = gitLabAwardName(input.content);
+  for (const entry of entries) {
+    const award = asObject3(entry);
+    const id = int2(award?.id);
+    if (award === null || id === null) continue;
+    if (text4(award.name)?.toLowerCase() !== name) continue;
+    if (text4(asObject3(award.user)?.username) !== input.viewer) continue;
+    return { awardId: id };
+  }
+  return { awardId: null };
+};
+
+// src/gitlabCommands.ts
+var CAPABILITIES2 = {
+  diff: true,
+  comment: true,
+  actions: [
+    "merge",
+    "ready",
+    "draft",
+    "close",
+    "reopen",
+    "update-branch",
+    "enable-auto-merge",
+    "disable-auto-merge"
+  ],
+  // GitLab offers all three, though a project settles on one; `mergeCapabilities` narrows it.
+  mergeMethods: ["merge", "squash", "rebase"],
+  // Rebase alone: GitLab moves a stale branch onto its target by replaying it, and has nothing
+  // that merges the target back in the way GitHub's update button can. Declaring only what it
+  // does is what lets a request to merge the target in be refused instead of quietly rebasing.
+  updateMethods: ["rebase"],
+  search: true,
+  reactions: true,
+  review: {
+    inlineComment: true,
+    reply: true,
+    resolve: true,
+    // No "changes requested": GitLab has approval and unresolved discussions, and nothing that
+    // says a merge request has been reviewed and rejected.
+    verdicts: ["comment", "approve"]
+  },
+  reviewers: { request: true, listCandidates: true },
+  edit: { changeRequest: true, comment: true }
+};
+var MAX_PAGE_SIZE = 100;
+var COMMIT_PAGE_SIZE = 100;
+var CONVERSATION_PAGES = 10;
+var DIFF_MAX_BYTES2 = 8 * 1024 * 1024;
+var DIFF_TIMEOUT_MS2 = 6e4;
+var MERGE_ACTIONS = /* @__PURE__ */ new Set([
+  "merge",
+  "update-branch",
+  "enable-auto-merge",
+  "disable-auto-merge"
+]);
+var gitLabViewerPermissions = (input) => ({
+  // 布置自动合并与撤销布置就是延后的合并，跟着同一个 `can_merge`。
+  actions: CAPABILITIES2.actions.filter(
+    (action) => !MERGE_ACTIONS.has(action) || input.viewerCanMerge
+  ),
+  comment: true,
+  resolve: true,
+  verdicts: CAPABILITIES2.review.verdicts,
+  requestReviewers: true,
+  ...input.viewerCanMerge ? { updateMethods: CAPABILITIES2.updateMethods } : {}
+});
+var projectPath = (repository) => encodeURIComponent(repository.trim());
+var query = (params) => params.map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join("&");
+var stateParam = (state) => (
+  // GitLab 的 `closed` 本来就不含已合并的，不用再加过滤；`all` 覆盖全部状态。
+  state === "open" ? "opened" : state
+);
+var involvementParams = (input) => {
+  switch (input.involvement) {
+    case "authored":
+      return [["author_username", input.viewer]];
+    case "reviewing":
+      return [["reviewer_username", input.viewer]];
+    case "all":
+      return [];
+  }
+};
+var searchParams = (search) => {
+  const trimmed = search?.trim() ?? "";
+  return trimmed.length === 0 ? [] : [["search", trimmed]];
+};
+var diffCursorPage2 = (cursor) => /^[1-9][0-9]{0,6}$/.test(cursor) ? Number(cursor) : null;
+var isCommitSha2 = (value) => /^[0-9a-f]{7,64}$/i.test(value);
+var DRAFT_PREFIX = /^\s*(?:\[draft\]|\(draft\)|draft:|wip:)\s*/i;
+var reviewPositionLines = (position) => {
+  switch (position.kind) {
+    case "added":
+      return { new_line: position.newLine };
+    case "deleted":
+      return { old_line: position.oldLine };
+    case "context":
+      return { old_line: position.oldLine, new_line: position.newLine };
+  }
+};
+var mergeRequestPath = (input) => `projects/${projectPath(input.repository)}/merge_requests/${input.number}`;
+var getViewer2 = async (ctx) => {
+  const result = await callGitLabApi(ctx, {
+    operation: "getViewer",
+    path: "user"
+  });
+  const decoded = decodeViewer(result.body.trim());
+  if (decoded === null) throw readError2("getViewer", "getViewerUsername");
+  if (decoded.username === null) {
+    throw new GitLabError({
+      code: "failed",
+      operation: "getViewer",
+      detail: "GitLab returned no username for the authenticated account."
+    });
+  }
+  return decoded.username;
+};
+var listChangeRequests2 = async (ctx, input) => {
+  const delivered = input.cursor?.delivered ?? 0;
+  const perPage = Math.min(input.limit + 1, MAX_PAGE_SIZE);
+  const firstPage = Math.floor(delivered / perPage) + 1;
+  const lastPage = Math.floor((delivered + input.limit) / perPage) + 1;
+  let page = firstPage;
+  let collected = [];
+  let cursorAdvance = 0;
+  for (; ; ) {
+    const skipOnFirstPage = page === firstPage ? delivered % perPage : 0;
+    const result = await callGitLabApi(ctx, {
+      operation: "listChangeRequests",
+      host: input.host,
+      path: `projects/${projectPath(input.repository)}/merge_requests?${query([
+        ["state", stateParam(input.state)],
+        ...involvementParams(input),
+        // 搜索用 REST 自己的 `search` 参数（匹配标题与描述），并像别的值一样 URL
+        // 编码，里面的文字变不成另一个参数。
+        ...searchParams(input.query),
+        ["order_by", "updated_at"],
+        ["sort", "desc"],
+        ["per_page", String(perPage)],
+        ["page", String(page)]
+      ])}`
+    });
+    const raw = result.body.trim();
+    if (raw.length === 0) {
+      return { items: collected, truncated: false, cursorAdvance, continues: true };
+    }
+    const decoded = decodeMergeRequestList(raw);
+    if (decoded === null) throw readError2("listChangeRequests", "listMergeRequests");
+    const pageItems = [];
+    const pageRawIndexes = [];
+    for (const [index, item] of decoded.items.entries()) {
+      const rawIndex = decoded.rawIndexes[index];
+      if (rawIndex < skipOnFirstPage) continue;
+      pageItems.push(item);
+      pageRawIndexes.push(rawIndex);
+    }
+    const remaining = input.limit - collected.length;
+    const lastItemRawIndex = pageRawIndexes[remaining - 1];
+    if (lastItemRawIndex !== void 0) {
+      return {
+        items: [...collected, ...pageItems.slice(0, remaining)],
+        truncated: lastItemRawIndex + 1 < decoded.rawCount || decoded.rawCount === perPage,
+        cursorAdvance: cursorAdvance + (lastItemRawIndex + 1 - skipOnFirstPage),
+        continues: true
+      };
+    }
+    collected = [...collected, ...pageItems];
+    cursorAdvance += Math.max(0, decoded.rawCount - skipOnFirstPage);
+    if (decoded.rawCount < perPage) {
+      return { items: collected, truncated: false, cursorAdvance, continues: true };
+    }
+    if (page >= lastPage) {
+      return { items: collected, truncated: true, cursorAdvance, continues: true };
+    }
+    page += 1;
+  }
+};
+var mergeRequestDetail = async (ctx, input, operation) => {
+  const result = await callGitLabApi(ctx, {
+    operation,
+    host: input.host,
+    // 落后目标分支多少只有点名要才给，而且就在这一次读里要——同一条合并请求，不值得
+    // 再发一个请求。
+    path: `${mergeRequestPath(input)}?${query([["include_diverged_commits_count", "true"]])}`
+  });
+  const decoded = decodeMergeRequestDetail(result.body.trim());
+  if (decoded === null) throw readError2(operation, "getMergeRequestDetail");
+  return decoded;
+};
+var projectMergeCapabilities = async (ctx, input, operation) => {
+  const result = await callGitLabApi(ctx, {
+    operation,
+    host: input.host,
+    path: `projects/${projectPath(input.repository)}?license=false`
+  });
+  const decoded = decodeProjectMergeCapabilities(result.body.trim());
+  if (decoded === null) throw readError2(operation, "getProjectMergeCapabilities");
+  return decoded;
+};
+var getChangeRequest2 = async (ctx, input) => {
+  const [mergeRequest, mergeCapabilities] = await Promise.all([
+    mergeRequestDetail(ctx, input, "getChangeRequest"),
+    projectMergeCapabilities(ctx, input, "getChangeRequest")
+  ]);
+  return {
+    ...mergeRequest,
+    mergeCapabilities,
+    viewerPermissions: gitLabViewerPermissions(mergeRequest),
+    // 数不出分歧数的老 GitLab 什么都不说，而不是说「已是最新」：横幅丢了不要紧，一个
+    // 错误的「一切正常」不值得显示。
+    baseComparison: mergeRequest.divergedCommits === void 0 ? "unknown" : mergeRequest.divergedCommits > 0 ? "behind" : "up-to-date",
+    ...mergeRequest.divergedCommits === void 0 ? {} : { behindBy: mergeRequest.divergedCommits }
+  };
+};
+var getViewerPermissions2 = async (ctx, input) => (
+  // 与 detail 取自同一次读：`user.can_merge` 就长在合并请求上，没有更便宜的问法。
+  gitLabViewerPermissions(await mergeRequestDetail(ctx, input, "getViewerPermissions"))
+);
+var listNotes = async (ctx, input) => {
+  let collected = [];
+  for (let page = 1; ; page += 1) {
+    const result = await callGitLabApi(ctx, {
+      operation: "listNotes",
+      host: input.host,
+      path: `${mergeRequestPath(input)}/notes?${query([
+        ["per_page", String(MAX_PAGE_SIZE)],
+        ["page", String(page)],
+        ["order_by", "created_at"],
+        ["sort", "asc"]
+      ])}`
+    });
+    const decoded = decodeNotes(result.body.trim());
+    if (decoded === null) throw readError2("listNotes", "listNotes");
+    collected = [...collected, ...decoded.comments];
+    if (decoded.rawCount < MAX_PAGE_SIZE) return { comments: collected, truncated: false };
+    if (page >= CONVERSATION_PAGES) return { comments: collected, truncated: true };
+  }
+};
+var listDiscussions = async (ctx, input) => {
+  let collected = [];
+  for (let page = 1; ; page += 1) {
+    const result = await callGitLabApi(ctx, {
+      operation: "listDiscussions",
+      host: input.host,
+      path: `${mergeRequestPath(input)}/discussions?${query([
+        ["per_page", String(MAX_PAGE_SIZE)],
+        ["page", String(page)]
+      ])}`
+    });
+    const decoded = decodeDiscussions(result.body.trim());
+    if (decoded === null) throw readError2("listDiscussions", "listDiscussions");
+    collected = [...collected, ...decoded.threads];
+    if (decoded.rawCount < MAX_PAGE_SIZE) return { threads: collected, truncated: false };
+    if (page >= CONVERSATION_PAGES) return { threads: collected, truncated: true };
+  }
+};
+var listCommits = async (ctx, input) => {
+  const result = await callGitLabApi(ctx, {
+    operation: "listCommits",
+    host: input.host,
+    path: `${mergeRequestPath(input)}/commits?${query([
+      ["per_page", String(COMMIT_PAGE_SIZE)],
+      ["with_stats", "true"]
+    ])}`
+  });
+  const decoded = decodeCommits(result.body.trim());
+  if (decoded === null) throw readError2("listCommits", "listCommits");
+  return decoded;
+};
+var listReactions = async (ctx, input) => {
+  let cursor = null;
+  let reactions = [];
+  const reactionsByNoteId = /* @__PURE__ */ new Map();
+  for (let page = 1; ; page += 1) {
+    const result = await callGitLabGraphQl(ctx, {
+      operation: "listReactions",
+      host: input.host,
+      body: JSON.stringify({
+        query: AWARD_EMOJI_GRAPHQL_QUERY,
+        variables: { fullPath: input.repository, iid: String(input.number), cursor }
+      })
+    });
+    const decoded = decodeAwardEmoji(result.body.trim());
+    if (decoded === null) throw readError2("listReactions", "listReactions");
+    if (page === 1) reactions = decoded.reactions;
+    for (const [id, noteReactions] of decoded.reactionsByNoteId) {
+      reactionsByNoteId.set(id, noteReactions);
+    }
+    if (decoded.nextCursor === null || page >= CONVERSATION_PAGES) {
+      return { reactions, reactionsByNoteId };
+    }
+    cursor = decoded.nextCursor;
+  }
+};
+var orElse = (promise, fallback) => promise.catch(() => fallback);
+var getChangeRequestActivity2 = async (ctx, input) => {
+  const [notes, commits, discussions, awards] = await Promise.all([
+    orElse(listNotes(ctx, input), {
+      comments: [],
+      truncated: true
+    }),
+    orElse(listCommits(ctx, input), []),
+    orElse(listDiscussions(ctx, input), {
+      threads: [],
+      truncated: true
+    }),
+    // notes 端点一个表情都不带，所以跟它并排读。读挂了赔掉的是对话的表情，不是它的字。
+    orElse(listReactions(ctx, input), {
+      reactions: [],
+      reactionsByNoteId: /* @__PURE__ */ new Map()
+    })
+  ]);
+  return {
+    reactions: awards.reactions,
+    comments: notes.comments.map((comment3) => ({
+      ...comment3,
+      reactions: awards.reactionsByNoteId.get(comment3.id) ?? []
+    })),
+    // GitLab 不报自己的总数，所以这次走出来的总数就是主机的：notes 端点带着合并请求
+    // 上的每一条评论，包括写在讨论下面的，一直读到 GitLab 没有为止。
+    commentCount: notes.comments.length,
+    commentsTruncated: notes.truncated || discussions.truncated,
+    reviewThreads: discussions.threads.map((thread) => ({
+      ...thread,
+      comments: thread.comments.map((comment3) => ({
+        ...comment3,
+        reactions: awards.reactionsByNoteId.get(comment3.id) ?? []
+      }))
+    })),
+    commits
+  };
+};
+var diffPage = async (ctx, input) => {
+  const result = await callGitLabApi(ctx, {
+    operation: "getDiff",
+    host: input.host,
+    path: `projects/${projectPath(input.repository)}/${input.commit === void 0 ? `merge_requests/${input.number}/diffs` : `repository/commits/${input.commit}/diff`}?${query([
+      ["per_page", String(MAX_PAGE_SIZE)],
+      ["page", String(input.page)]
+    ])}`,
+    maxBytes: DIFF_MAX_BYTES2,
+    timeoutMs: DIFF_TIMEOUT_MS2
+  });
+  if (result.truncated) {
+    throw new GitLabError({
+      code: "failed",
+      operation: "getDiff",
+      detail: `Page ${input.page} of the merge request diff was too large to read.`
+    });
+  }
+  const decoded = decodeMergeRequestDiffs(result.body.trim());
+  if (decoded === null) throw readError2("getDiff", "getMergeRequestDiff");
+  const morePages = decoded.rawCount >= MAX_PAGE_SIZE;
+  return {
+    // 切片以换行结尾，GitLab 只给了头没给 hunk 的文件才不会撞进下一段的第一行。
+    patch: decoded.patch.length === 0 ? decoded.patch : decoded.patch.replace(/\n?$/, "\n"),
+    truncated: decoded.truncated,
+    nextCursor: morePages ? String(input.page + 1) : null
+  };
+};
+var getDiff2 = (ctx, input) => {
+  if (input.commit !== void 0 && !isCommitSha2(input.commit)) {
+    return Promise.reject(
+      new GitLabError({
+        code: "failed",
+        operation: "getDiff",
+        detail: "The named commit was not a commit sha."
+      })
+    );
+  }
+  const target = {
+    cwd: input.cwd,
+    repository: input.repository,
+    host: input.host,
+    number: input.number,
+    ...input.commit === void 0 ? {} : { commit: input.commit }
+  };
+  if (input.cursor === void 0) return diffPage(ctx, { ...target, page: 1 });
+  const page = diffCursorPage2(input.cursor);
+  return page === null ? Promise.reject(
+    new GitLabError({
+      code: "failed",
+      operation: "getDiff",
+      detail: "The diff cursor was not one this merge request handed out."
+    })
+  ) : diffPage(ctx, { ...target, page });
+};
+var projectUsers = async (ctx, input) => {
+  const result = await callGitLabApi(ctx, {
+    operation: "listReviewerCandidates",
+    host: input.host,
+    path: `projects/${projectPath(input.repository)}/users?${query([
+      ["per_page", String(MAX_PAGE_SIZE)]
+    ])}`
+  });
+  const decoded = decodeProjectUsers(result.body.trim());
+  if (decoded === null) throw readError2("listReviewerCandidates", "listReviewerCandidates");
+  return decoded;
+};
+var listReviewerCandidates2 = async (ctx, input) => {
+  const [mergeRequest, users] = await Promise.all([
+    mergeRequestDetail(ctx, input, "listReviewerCandidates"),
+    projectUsers(ctx, input)
+  ]);
+  const author = mergeRequest.author?.login;
+  const requested = new Set(mergeRequest.reviewRequestLogins);
+  return {
+    // 作者被剔掉而不是显示成不能用的一项：GitLab 不让开合并请求的人当它的评审人。
+    candidates: users.candidates.flatMap(
+      (candidate) => candidate.login === author ? [] : [{ ...candidate, isRequested: requested.has(candidate.login) }]
+    ),
+    truncated: users.rawCount >= MAX_PAGE_SIZE
+  };
+};
+var setReviewerRequest2 = async (ctx, input) => {
+  const mergeRequest = await mergeRequestDetail(ctx, input, "setReviewerRequest");
+  const ids = new Set(mergeRequest.reviewerIds);
+  for (const reviewer of input.reviewers) {
+    const id = Number(reviewer.id);
+    if (!Number.isSafeInteger(id) || id <= 0) continue;
+    if (input.requested) ids.add(id);
+    else ids.delete(id);
+  }
+  await callGitLabApi(ctx, {
+    operation: "setReviewerRequest",
+    host: input.host,
+    path: mergeRequestPath(input),
+    method: "PUT",
+    body: JSON.stringify({ reviewer_ids: [...ids] })
+  });
+  return null;
+};
+var runAction2 = async (ctx, input) => {
+  const write = (path2, method, body) => callGitLabApi(ctx, {
+    operation: "runAction",
+    host: input.host,
+    path: path2,
+    method,
+    ...body === void 0 ? {} : { body }
+  });
+  switch (input.action) {
+    // 合并策略定在项目上（`mergeCapabilities` 报的就是它），端点只认 squash 这一个开关。
+    // `merge_when_pipeline_succeeds` 显式写死两个方向：默认由 GitLab 决定的话，有流水线
+    // 在跑时「现在就合」会静默变成「排队等」。
+    case "merge":
+    case "enable-auto-merge":
+      await write(
+        `${mergeRequestPath(input)}/merge`,
+        "PUT",
+        JSON.stringify({
+          squash: input.mergeMethod === "squash",
+          merge_when_pipeline_succeeds: input.action === "enable-auto-merge"
+        })
+      );
+      return null;
+    case "disable-auto-merge":
+      await write(`${mergeRequestPath(input)}/cancel_merge_when_pipeline_succeeds`, "POST");
+      return null;
+    // rebase，因为 GitLab 没有别的办法把分支挪到目标上：它没有 GitHub 那个把目标合
+    // 进来的更新按钮，这也是这家只声明 `rebase` 的原因。
+    case "update-branch":
+      await write(`${mergeRequestPath(input)}/rebase`, "PUT");
+      return null;
+    case "close":
+    case "reopen":
+      await write(mergeRequestPath(input), "PUT", JSON.stringify({ state_event: input.action }));
+      return null;
+    // 进出草稿要先读标题：改的是前缀，而 GitLab 只接受写回一个完整的新标题。
+    case "ready":
+    case "draft": {
+      const mergeRequest = await mergeRequestDetail(ctx, input, "runAction");
+      const title = mergeRequest.title.replace(DRAFT_PREFIX, "").trim();
+      await write(
+        mergeRequestPath(input),
+        "PUT",
+        JSON.stringify({ title: input.action === "draft" ? `Draft: ${title}` : title })
+      );
+      return null;
+    }
+  }
+};
+var updateChangeRequest2 = async (ctx, input) => {
+  await callGitLabApi(ctx, {
+    operation: "updateChangeRequest",
+    host: input.host,
+    path: mergeRequestPath(input),
+    method: "PUT",
+    // 只发调用方要改的字段：GitLab 不发的就不动，发了空的就清掉——所以单独改标题时
+    // 一个描述字段都不能带。
+    body: JSON.stringify({
+      ...input.title === void 0 ? {} : { title: input.title },
+      ...input.body === void 0 ? {} : { description: input.body }
+    })
+  });
+  return null;
+};
+var comment2 = async (ctx, input) => {
+  await callGitLabApi(ctx, {
+    operation: "comment",
+    host: input.host,
+    path: `${mergeRequestPath(input)}/notes`,
+    method: "POST",
+    body: JSON.stringify({ body: input.body })
+  });
+  return null;
+};
+var updateComment2 = async (ctx, input) => {
+  await callGitLabApi(ctx, {
+    operation: "updateComment",
+    host: input.host,
+    path: `${mergeRequestPath(input)}/notes/${encodeURIComponent(input.commentId)}`,
+    method: "PUT",
+    body: JSON.stringify({ body: input.body })
+  });
+  return null;
+};
+var getDiffRefs = async (ctx, input, operation) => {
+  const result = await callGitLabApi(ctx, {
+    operation,
+    host: input.host,
+    path: mergeRequestPath(input)
+  });
+  const decoded = decodeDiffRefs(result.body.trim());
+  if (decoded === null) throw readError2(operation, "getDiffRefs");
+  if (decoded.refs === null) {
+    throw new GitLabError({
+      code: "failed",
+      operation,
+      detail: "The merge request reported no diff revisions."
+    });
+  }
+  return decoded.refs;
+};
+var submitReview2 = async (ctx, input) => {
+  const mergeRequest = mergeRequestPath(input);
+  if (input.comments.length > 0) {
+    const refs = await getDiffRefs(ctx, input, "submitReview");
+    for (const draft of input.comments) {
+      await callGitLabApi(ctx, {
+        operation: "submitReview",
+        host: input.host,
+        path: `${mergeRequest}/discussions`,
+        method: "POST",
+        body: JSON.stringify({
+          body: draft.body,
+          position: {
+            base_sha: refs.baseSha,
+            head_sha: refs.headSha,
+            start_sha: refs.startSha,
+            position_type: "text",
+            // 两个路径都发，因为 GitLab 对着 diff 的两侧解析位置。它们只在改名的文件
+            // 上不同，这也是草稿带着改名前那个名字的原因。
+            old_path: draft.oldPath ?? draft.path,
+            new_path: draft.path,
+            ...reviewPositionLines(draft.position)
+          }
+        })
+      });
+    }
+  }
+  if (input.body.trim().length > 0) {
+    await callGitLabApi(ctx, {
+      operation: "submitReview",
+      host: input.host,
+      path: `${mergeRequest}/notes`,
+      method: "POST",
+      body: JSON.stringify({ body: input.body })
+    });
+  }
+  if (input.verdict === "approve") {
+    await callGitLabApi(ctx, {
+      operation: "submitReview",
+      host: input.host,
+      path: `${mergeRequest}/approve`,
+      method: "POST"
+    });
+  }
+  return null;
+};
+var replyToThread2 = async (ctx, input) => {
+  await callGitLabApi(ctx, {
+    operation: "replyToThread",
+    host: input.host,
+    path: `${mergeRequestPath(input)}/discussions/${encodeURIComponent(input.threadId)}/notes`,
+    method: "POST",
+    body: JSON.stringify({ body: input.body })
+  });
+  return null;
+};
+var setThreadResolution2 = async (ctx, input) => {
+  await callGitLabApi(ctx, {
+    operation: "setThreadResolution",
+    host: input.host,
+    path: `${mergeRequestPath(input)}/discussions/${encodeURIComponent(input.threadId)}`,
+    method: "PUT",
+    body: JSON.stringify({ resolved: input.resolved })
+  });
+  return null;
+};
+var awardSubjectPath = (input) => input.subjectId === void 0 ? `${mergeRequestPath(input)}/award_emoji` : `${mergeRequestPath(input)}/notes/${encodeURIComponent(input.subjectId)}/award_emoji`;
+var setReaction2 = async (ctx, input) => {
+  const subject = awardSubjectPath(input);
+  if (input.reacted) {
+    await callGitLabApi(ctx, {
+      operation: "setReaction",
+      host: input.host,
+      path: `${subject}?${query([["name", gitLabAwardName(input.content)]])}`,
+      method: "POST"
+    });
+    return null;
+  }
+  const viewer = await getViewer2(ctx);
+  const listed = await callGitLabApi(ctx, {
+    operation: "setReaction",
+    host: input.host,
+    path: subject
+  });
+  const own = decodeOwnAwardId(listed.body.trim(), { content: input.content, viewer });
+  if (own === null) throw readError2("setReaction", "setReaction");
+  if (own.awardId === null) return null;
+  await callGitLabApi(ctx, {
+    operation: "setReaction",
+    host: input.host,
+    path: `${subject}/${own.awardId}`,
+    method: "DELETE"
+  });
+  return null;
+};
+
+// src/service/providerApi.ts
+var CODES = [
+  "missing-tool",
+  "unauthenticated",
+  "rate-limited",
+  "failed"
+];
+var providerFailureOf = (error) => {
+  const held = error;
+  const code = CODES.find((candidate) => candidate === held?.code) ?? "failed";
+  const retryAt = held?.data?.retryAt;
+  return {
+    code,
+    detail: typeof held?.message === "string" ? held.message : String(error),
+    ...typeof retryAt === "number" && Number.isFinite(retryAt) ? { retryAt } : {}
+  };
+};
+var gitlabApi = (ctx) => ({
+  kind: "gitlab",
+  capabilities: CAPABILITIES2,
+  hosts: [configuredHost2(ctx)],
+  getViewer: () => getViewer2(ctx),
+  listChangeRequests: (input) => listChangeRequests2(ctx, input),
+  getChangeRequest: (input) => getChangeRequest2(ctx, input),
+  getChangeRequestActivity: (input) => getChangeRequestActivity2(ctx, input),
+  getViewerPermissions: (input) => getViewerPermissions2(ctx, input),
+  getDiff: (input) => getDiff2(ctx, input),
+  listReviewerCandidates: (input) => listReviewerCandidates2(ctx, input),
+  setReviewerRequest: (input) => setReviewerRequest2(ctx, input),
+  runAction: (input) => runAction2(ctx, input),
+  updateChangeRequest: (input) => updateChangeRequest2(ctx, input),
+  comment: (input) => comment2(ctx, input),
+  updateComment: (input) => updateComment2(ctx, input),
+  submitReview: (input) => submitReview2(ctx, input),
+  replyToThread: (input) => replyToThread2(ctx, input),
+  setReaction: (input) => setReaction2(ctx, input),
+  setThreadResolution: (input) => setThreadResolution2(ctx, input)
+});
+var githubApi = (ctx) => ({
+  kind: "github",
+  capabilities: CAPABILITIES,
+  hosts: [configuredHost(ctx)],
+  getViewer: () => getViewer(ctx),
+  listChangeRequests: (input) => listChangeRequests(ctx, input),
+  listChangeRequestsAcross: (input) => listChangeRequestsAcross(ctx, input),
+  listChangeRequestStats: (input) => listChangeRequestStats(ctx, input),
+  getChangeRequest: (input) => getChangeRequest(ctx, input),
+  getChangeRequestActivity: (input) => getChangeRequestActivity(ctx, input),
+  getReviewThreadComments: (input) => getReviewThreadComments(ctx, input),
+  getViewerPermissions: (input) => getViewerPermissions(ctx, input),
+  getDiff: (input) => getDiff(ctx, input),
+  getDiffFileContents: (input) => getDiffFileContents(ctx, input),
+  listReviewerCandidates: (input) => listReviewerCandidates(ctx, input),
+  setReviewerRequest: (input) => setReviewerRequest(ctx, input),
+  runAction: (input) => runAction(ctx, input),
+  updateChangeRequest: (input) => updateChangeRequest(ctx, input),
+  comment: (input) => comment(ctx, input),
+  updateComment: (input) => updateComment(ctx, input),
+  submitReview: (input) => submitReview(ctx, input),
+  replyToThread: (input) => replyToThread(ctx, input),
+  setReaction: (input) => setReaction(ctx, input),
+  setThreadResolution: (input) => setThreadResolution(ctx, input)
+});
+var ProviderRateLimited = class extends Error {
+  code = "rate-limited";
+  data;
+  constructor(input) {
+    super(`Rate limited in ${input.operation}: ${input.detail}`);
+    this.name = "ProviderRateLimited";
+    this.data = { retryAt: input.retryAt };
+  }
+};
+var withRateLimitBackoff = (api, host, backoff) => {
+  const key = { provider: api.kind, host };
+  const wrap = (operation, call, allowPaused = false) => async (input) => {
+    const gate = backoff.check(key, { allowPaused });
+    if (isPaused(gate)) {
+      throw new ProviderRateLimited({
+        operation,
+        detail: `${api.kind} requests to ${gate.host} are paused until the rate limit resets.`,
+        retryAt: gate.retryAt
+      });
+    }
+    try {
+      const value = await call(input);
+      backoff.recordSuccess({ ...key, lease: gate.lease });
+      return value;
+    } catch (error) {
+      const failure = providerFailureOf(error);
+      if (failure.code === "rate-limited") {
+        backoff.recordRateLimit({ ...key, lease: gate.lease, retryAt: failure.retryAt });
+      }
+      throw error;
+    }
+  };
+  const across = api.listChangeRequestsAcross;
+  const stats = api.listChangeRequestStats;
+  const threadComments = api.getReviewThreadComments;
+  const fileContents = api.getDiffFileContents;
+  const rewrite = api.updateChangeRequest;
+  const rewriteComment = api.updateComment;
+  return {
+    kind: api.kind,
+    capabilities: api.capabilities,
+    hosts: api.hosts,
+    getViewer: wrap("getViewer", api.getViewer),
+    listChangeRequests: wrap("listChangeRequests", api.listChangeRequests),
+    ...across === void 0 ? {} : { listChangeRequestsAcross: wrap("listChangeRequestsAcross", across) },
+    ...stats === void 0 ? {} : { listChangeRequestStats: wrap("listChangeRequestStats", stats) },
+    getChangeRequest: wrap("getChangeRequest", api.getChangeRequest),
+    getChangeRequestActivity: wrap("getChangeRequestActivity", api.getChangeRequestActivity),
+    ...threadComments === void 0 ? {} : { getReviewThreadComments: wrap("getReviewThreadComments", threadComments) },
+    getViewerPermissions: wrap("getViewerPermissions", api.getViewerPermissions, true),
+    getDiff: wrap("getDiff", api.getDiff),
+    ...fileContents === void 0 ? {} : { getDiffFileContents: wrap("getDiffFileContents", fileContents) },
+    listReviewerCandidates: wrap("listReviewerCandidates", api.listReviewerCandidates, true),
+    setReviewerRequest: wrap("setReviewerRequest", api.setReviewerRequest, true),
+    runAction: wrap("runAction", api.runAction, true),
+    ...rewrite === void 0 ? {} : { updateChangeRequest: wrap("updateChangeRequest", rewrite, true) },
+    comment: wrap("comment", api.comment, true),
+    ...rewriteComment === void 0 ? {} : { updateComment: wrap("updateComment", rewriteComment, true) },
+    submitReview: wrap("submitReview", api.submitReview, true),
+    replyToThread: wrap("replyToThread", api.replyToThread, true),
+    setReaction: wrap("setReaction", api.setReaction, true),
+    setThreadResolution: wrap("setThreadResolution", api.setThreadResolution, true)
+  };
+};
+
+// src/service/workspace.ts
+var repositoryIdentityOf = (identity) => {
+  if (identity.displayName) return identity.displayName;
+  return identity.owner && identity.name ? `${identity.owner}/${identity.name}` : null;
+};
+var hostOf = (identity, kind) => {
+  const host = identity.canonicalKey.split("/")[0]?.trim();
+  return host === void 0 || host.length === 0 ? kind : host.toLowerCase();
+};
+var remoteHostOf = (remoteUrl) => {
+  const normalized = remoteUrl.trim().replace(/\/+$/g, "").toLowerCase();
+  if (/^(?:ssh|https?|git):\/\//i.test(normalized)) {
+    try {
+      return new URL(normalized).hostname;
+    } catch {
+      return "";
+    }
+  }
+  return /^[a-z0-9._-]+@([^:/\s]+):/i.exec(normalized)?.[1] ?? "";
+};
+var claimTable = (apis) => {
+  const claims = /* @__PURE__ */ new Map();
+  for (const api of apis) {
+    for (const host of api.hosts) {
+      if (host.length > 0 && !claims.has(host)) claims.set(host, api.kind);
+    }
+  }
+  return claims;
+};
+var listWorkspaceProjects = async (input) => {
+  const projects = await input.listProjects();
+  const claims = claimTable(input.apis);
+  const byKind = new Map(input.apis.map((api) => [api.kind, api]));
+  const supported = [];
+  const unimplemented = /* @__PURE__ */ new Map();
+  const viewerRoots = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  for (const project of projects) {
+    if (input.filter.projectId !== void 0 && project.projectId !== input.filter.projectId) {
+      continue;
+    }
+    if (input.filter.projectIds !== void 0 && !input.filter.projectIds.includes(project.projectId)) {
+      continue;
+    }
+    const identity = project.repositoryIdentity;
+    if (identity === null) continue;
+    const repository = repositoryIdentityOf(identity);
+    if (repository === null) continue;
+    let kind = identity.provider;
+    if (kind === "unknown") {
+      const claimed = claims.get(remoteHostOf(identity.remoteUrl));
+      if (claimed !== void 0) kind = claimed;
+    }
+    const host = hostOf(identity, kind);
+    if (input.filter.host !== void 0 && host !== input.filter.host.trim().toLowerCase()) {
+      continue;
+    }
+    const api = byKind.get(kind) ?? null;
+    if (api !== null) {
+      const roots = viewerRoots.get(host);
+      if (roots === void 0) viewerRoots.set(host, [project.workspaceRoot]);
+      else if (!roots.includes(project.workspaceRoot)) roots.push(project.workspaceRoot);
+    }
+    const key = listCursorKey(host, repository);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (api === null) {
+      const counted = unimplemented.get(host);
+      if (counted === void 0) unimplemented.set(host, { kind, projectCount: 1 });
+      else counted.projectCount += 1;
+      continue;
+    }
+    supported.push({
+      projectId: project.projectId,
+      projectTitle: project.title,
+      workspaceRoot: project.workspaceRoot,
+      api: withRateLimitBackoff(api, host, input.backoff),
+      repository,
+      host
+    });
+  }
+  return { supported, unimplemented, viewerRoots };
+};
+
+// src/service/pullRequestService.ts
+var DEFAULT_REPOSITORY_LIST_LIMIT = 99;
+var REPOSITORY_CONCURRENCY = 12;
+var REPOSITORY_SEARCH_CHUNK = 100;
+var LIST_CACHE_TTL_MS = 3e4;
+var DETAIL_CACHE_TTL_MS = 15e3;
+var DIFF_CACHE_TTL_MS = 6e4;
+var COMMIT_DIFF_CACHE_TTL_MS = 10 * 6e4;
+var LIST_STATS_CACHE_TTL_MS = 6e4;
+var DIFF_STALE_WINDOW_MS = 10 * 6e4;
+var VIEWER_CACHE_TTL_MS = 10 * 6e4;
+var LIST_CACHE_CAPACITY = 64;
+var LIST_STATS_CACHE_CAPACITY = 32;
+var DETAIL_CACHE_CAPACITY = 128;
+var DIFF_CACHE_CAPACITY = 128;
+var REF_EPOCH_CAPACITY = 2048;
+var VERDICT_LABELS = {
+  comment: "review",
+  approve: "approve",
+  "request-changes": "request changes on"
+};
+var ACTION_ACCESS_REFUSALS = {
+  merge: "You need write access on this repository to merge.",
+  ready: "You need write access on this repository, or to have opened this change request, to mark it ready for review.",
+  draft: "You need write access on this repository, or to have opened this change request, to return it to a draft.",
+  close: "You need write access on this repository, or to have opened this change request, to close it.",
+  "update-branch": "You need write access on this repository, or to have opened this change request, to update its branch.",
+  reopen: "You need write access on this repository, or to have opened this change request, to reopen it.",
+  "enable-auto-merge": "You need write access on this repository to have it merged for you once it is ready.",
+  "disable-auto-merge": "You need write access on this repository to stop it being merged for you once it is ready."
+};
+var REVIEWER_REQUEST_REFUSAL = "You need write access on this repository to ask for a review.";
+var mapConcurrent = async (items, limit, run) => {
+  const results = Array.from({ length: items.length });
+  let next = 0;
+  await Promise.all(
+    Array.from({ length: Math.min(Math.max(limit, 1), items.length) }, async () => {
+      for (; ; ) {
+        const index = next++;
+        if (index >= items.length) return;
+        results[index] = await run(items[index]);
+      }
+    })
+  );
+  return results;
+};
+var firstSuccess = async (runs) => {
+  let last = new Error("nothing to try");
+  for (const run of runs) {
+    try {
+      return await run();
+    } catch (error) {
+      last = error;
+    }
+  }
+  throw last;
+};
+var isProviderUnusable = (failure) => failure.code === "missing-tool" || failure.code === "unauthenticated";
+var unavailableReasonOf = (failure) => failure.code === "missing-tool" ? "token-missing" : "token-rejected";
+var providerDetail = (failure, kind) => isProviderUnusable(failure) ? providerRequirement(kind, unavailableReasonOf(failure)) ?? failure.detail : failure.detail;
+var toPullRequestError = (operation, error, kind, host) => {
+  const failure = providerFailureOf(error);
+  if (isProviderUnusable(failure)) {
+    return new PullRequestUnavailable({
+      reason: unavailableReasonOf(failure),
+      provider: kind,
+      ...host === void 0 ? {} : { host }
+    });
+  }
+  return new PullRequestOperationFailed({
+    operation,
+    detail: failure.detail,
+    ...failure.retryAt === void 0 ? {} : { retryAt: failure.retryAt }
+  });
+};
+var resolveAuthorFilter = (author, viewer) => {
+  const trimmed = author.trim();
+  if (!/^@?me$/iu.test(trimmed)) return trimmed;
+  return viewer === null || viewer.trim().length === 0 ? trimmed : viewer;
+};
+var matchesRowFilters = (item, filters, viewer) => {
+  if (filters === void 0) return true;
+  const labels = new Set(item.labels.map((label) => label.name.trim().toLowerCase()));
+  const holds = (label) => labels.has(label.trim().toLowerCase());
+  return (filters.draft === void 0 || item.isDraft === (filters.draft === "only")) && // 判在 provider 行上而不是 entry 上：`null` 是「会汇总评审的主机说还没有结论」，
+  // 也就是 "none" 问的那个；`undefined` 是「这台主机根本不汇总」，那种行不判。
+  (filters.review === void 0 || item.reviewDecision === void 0 || (filters.review === "none" ? item.reviewDecision === null : item.reviewDecision === filters.review)) && (filters.labels === void 0 || filters.labels.every((group) => group.some(holds))) && (filters.excludedLabels === void 0 || !filters.excludedLabels.some(holds)) && (filters.author === void 0 || item.author?.login.toLowerCase() === resolveAuthorFilter(filters.author, viewer).toLowerCase());
+};
+var createPullRequestService = (options) => {
+  const now = options.now ?? Date.now;
+  const backoff = createBackoff({ now });
+  const workspace = (filter) => listWorkspaceProjects({
+    listProjects: options.listProjects,
+    apis: options.apis,
+    backoff,
+    filter
+  }).catch(() => {
+    throw new PullRequestOperationFailed({
+      operation: "listProjects",
+      detail: "The project list could not be read."
+    });
+  });
+  const requireProject = async (ref) => {
+    const { supported } = await workspace({ projectId: ref.projectId });
+    const match = supported[0];
+    if (!match) throw new PullRequestUnavailable({ reason: "provider-unsupported" });
+    if (match.repository.toLowerCase() !== ref.repository.trim().toLowerCase()) {
+      throw new PullRequestOperationFailed({
+        operation: "resolveRepository",
+        detail: "The change request does not belong to the selected project."
+      });
+    }
+    return match;
+  };
+  const changeRequestRef = (project, ref) => ({
+    cwd: project.workspaceRoot,
+    repository: project.repository,
+    host: project.host,
+    number: ref.number
+  });
+  const viewerPermissionsOf = async (project, ref, operation) => {
+    try {
+      return await project.api.getViewerPermissions(changeRequestRef(project, ref));
+    } catch (error) {
+      throw toPullRequestError(operation, error, project.api.kind, project.host);
+    }
+  };
+  const decodeCursors = (cursors) => {
+    if (cursors === void 0) return null;
+    const decoded = /* @__PURE__ */ new Map();
+    for (const [key, raw] of Object.entries(cursors)) {
+      const cursor = parseListCursor(raw);
+      if (cursor === null) {
+        throw new PullRequestOperationFailed({
+          operation: "list",
+          detail: "The list could not be carried on from where it left off."
+        });
+      }
+      decoded.set(key, cursor);
+    }
+    return decoded;
+  };
+  const viewersByHost = /* @__PURE__ */ new Map();
+  const resolveViewers = (projects, viewerRoots) => mapConcurrent(
+    [...new Set(projects.map(({ host }) => host))],
+    REPOSITORY_CONCURRENCY,
+    async (host) => {
+      const held = viewersByHost.get(host);
+      if (held !== void 0 && now() - held.at <= VIEWER_CACHE_TTL_MS) return held.result;
+      const forHost = projects.filter((project) => project.host === host);
+      const api = forHost[0].api;
+      const roots = viewerRoots.get(host) ?? forHost.map(({ workspaceRoot }) => workspaceRoot);
+      try {
+        const viewer = await firstSuccess(roots.map((cwd) => () => api.getViewer({ cwd })));
+        const result = { host, kind: api.kind, viewer, error: null };
+        viewersByHost.set(host, { at: now(), result });
+        return result;
+      } catch (error) {
+        return { host, kind: api.kind, viewer: null, error: providerFailureOf(error) };
+      }
+    }
+  );
+  const viewerOf = async (project) => {
+    const [resolved] = await resolveViewers([project], /* @__PURE__ */ new Map());
+    return resolved?.viewer ?? null;
+  };
+  const toEntry = (input) => {
+    const viewer = input.viewer.toLowerCase();
+    const { item, project } = input;
+    return {
+      provider: project.api.kind,
+      host: project.host,
+      projectId: project.projectId,
+      projectTitle: project.projectTitle,
+      repository: project.repository,
+      number: item.number,
+      title: item.title,
+      url: item.url,
+      author: item.author,
+      headBranch: item.headBranch,
+      baseBranch: item.baseBranch,
+      state: item.state,
+      isDraft: item.isDraft,
+      mergeability: item.mergeability,
+      additions: item.additions,
+      deletions: item.deletions,
+      createdAt: item.createdAt,
+      updatedAt: item.updatedAt,
+      ...item.checksState === void 0 || item.checksState === null ? {} : { checksState: item.checksState },
+      viewerReviewRequested: item.author?.login.toLowerCase() !== viewer && item.reviewRequestLogins.some((login) => login.toLowerCase() === viewer),
+      labels: item.labels,
+      ...item.reviewDecision === void 0 || item.reviewDecision === null ? {} : { reviewDecision: item.reviewDecision }
+    };
+  };
+  const listUncached = async (input) => {
+    const involvement = input.involvement ?? "all";
+    const continuation = decodeCursors(input.cursors);
+    const { supported: projects, unimplemented, viewerRoots } = await workspace(input);
+    const projectCounts = /* @__PURE__ */ new Map();
+    for (const { host } of projects) projectCounts.set(host, (projectCounts.get(host) ?? 0) + 1);
+    const viewerResults = await resolveViewers(projects, viewerRoots);
+    const viewers = {};
+    for (const result of viewerResults) {
+      if (result.viewer !== null) viewers[result.host] = result.viewer;
+    }
+    const providers = [
+      ...viewerResults.map((result) => ({
+        host: result.host,
+        kind: result.kind,
+        searchesOnHost: projects.find((project) => project.host === result.host)?.api.capabilities.search ?? false,
+        projectCount: projectCounts.get(result.host) ?? 1,
+        configured: result.viewer !== null,
+        detail: result.error === null ? null : providerDetail(result.error, result.kind)
+      })),
+      ...[...unimplemented].map(([host, { kind, projectCount }]) => ({
+        host,
+        kind,
+        searchesOnHost: false,
+        projectCount,
+        configured: false,
+        detail: "This host cannot be browsed here yet."
+      }))
+    ];
+    const selected = continuation === null ? projects : projects.filter(
+      ({ host, repository }) => continuation.has(listCursorKey(host, repository))
+    );
+    const readable = selected.filter(({ host }) => viewers[host] !== void 0);
+    const unreadable = selected.filter(({ host }) => viewers[host] === void 0).map(({ projectId, projectTitle, repository }) => ({
+      projectId,
+      projectTitle,
+      message: `${repository} could not be read.`
+    }));
+    if (readable.length === 0) {
+      const errors = viewerResults.flatMap(
+        (result) => result.error === null || !selected.some(({ host }) => host === result.host) ? [] : [{ failure: result.error, kind: result.kind, host: result.host }]
+      );
+      const blocking = errors.find((entry) => isProviderUnusable(entry.failure)) ?? errors[0];
+      if (blocking) {
+        const failure = blocking.failure;
+        if (isProviderUnusable(failure)) {
+          throw new PullRequestUnavailable({
+            reason: unavailableReasonOf(failure),
+            provider: blocking.kind,
+            host: blocking.host
+          });
+        }
+        throw new PullRequestOperationFailed({
+          operation: "list",
+          detail: failure.detail,
+          ...failure.retryAt === void 0 ? {} : { retryAt: failure.retryAt }
+        });
+      }
+      return { viewers, providers, entries: [], errors: [], truncated: false, nextCursors: {} };
+    }
+    const limit = input.limit ?? DEFAULT_REPOSITORY_LIST_LIMIT;
+    const cursorOf = (project) => continuation?.get(listCursorKey(project.host, project.repository));
+    const readRepository = async (project) => {
+      const viewer = viewers[project.host];
+      const key = listCursorKey(project.host, project.repository);
+      const cursor = cursorOf(project);
+      try {
+        const page = await project.api.listChangeRequests({
+          cwd: project.workspaceRoot,
+          repository: project.repository,
+          host: project.host,
+          state: input.state,
+          involvement,
+          viewer,
+          limit,
+          query: input.query,
+          filters: input.filters,
+          // 只递主机能用上的那两个字段：边界那一刻已经发过哪几行是服务自己的账。
+          ...cursor === void 0 ? {} : { cursor: { updatedBefore: cursor.updatedBefore, delivered: cursor.delivered } }
+        });
+        const items = withoutAlreadySent(cursor, page.items);
+        return {
+          key,
+          entries: items.filter((item) => matchesRowFilters(item, input.filters, viewer)).map((item) => toEntry({ project, item, viewer })),
+          errors: [],
+          truncated: page.truncated,
+          nextCursor: page.continues && page.truncated ? nextListCursor(cursor, page.items, items, page.cursorAdvance) : null
+        };
+      } catch {
+        return {
+          key,
+          entries: [],
+          errors: [
+            {
+              projectId: project.projectId,
+              projectTitle: project.projectTitle,
+              message: `${project.repository} could not be read.`
+            }
+          ],
+          truncated: false,
+          nextCursor: null
+        };
+      }
+    };
+    const readTogether = async (chunk) => {
+      const first = chunk[0];
+      const readAcross = first.api.listChangeRequestsAcross;
+      const separately = () => mapConcurrent(chunk, REPOSITORY_CONCURRENCY, readRepository);
+      if (readAcross === void 0) return separately();
+      const viewer = viewers[first.host];
+      const cursor = cursorOf(first);
+      let page;
+      try {
+        page = await readAcross({
+          cwd: first.workspaceRoot,
+          host: first.host,
+          repositories: chunk.map((project) => project.repository),
+          state: input.state,
+          involvement,
+          viewer,
+          limit,
+          query: input.query,
+          filters: input.filters,
+          ...cursor === void 0 ? {} : { cursor: { updatedBefore: cursor.updatedBefore, delivered: cursor.delivered } }
+        });
+      } catch {
+        return separately();
+      }
+      const rows = /* @__PURE__ */ new Map();
+      for (const item of page.items) {
+        const key = item.repository.trim().toLowerCase();
+        const held = rows.get(key);
+        if (held === void 0) rows.set(key, [item]);
+        else held.push(item);
+      }
+      const boundary = page.items.reduce(
+        (oldest, item) => oldest === null || item.updatedAt < oldest ? item.updatedAt : oldest,
+        null
+      );
+      return mapConcurrent(chunk, REPOSITORY_CONCURRENCY, async (project) => {
+        const fetched = rows.get(project.repository.trim().toLowerCase()) ?? [];
+        if (fetched.length === 0 && cursorOf(project) === void 0) return readRepository(project);
+        const cursorHere = cursorOf(project);
+        const items = withoutAlreadySent(cursorHere, fetched);
+        return {
+          key: listCursorKey(project.host, project.repository),
+          entries: items.filter((item) => matchesRowFilters(item, input.filters, viewer)).map((item) => toEntry({ project, item, viewer })),
+          errors: [],
+          truncated: page.truncated,
+          nextCursor: page.truncated && boundary !== null ? listCursorAt(cursorHere, boundary, fetched, items.length) : null
+        };
+      });
+    };
+    const together = /* @__PURE__ */ new Map();
+    const separate = [];
+    for (const project of readable) {
+      if (project.api.listChangeRequestsAcross === void 0) {
+        separate.push(project);
+        continue;
+      }
+      const key = `${project.host}
+${cursorOf(project)?.updatedBefore ?? ""}`;
+      const group = together.get(key);
+      if (group === void 0) together.set(key, [project]);
+      else group.push(project);
+    }
+    const reads = separate.map(
+      (project) => () => readRepository(project).then((batch) => [batch])
+    );
+    for (const group of together.values()) {
+      for (let start = 0; start < group.length; start += REPOSITORY_SEARCH_CHUNK) {
+        const chunk = group.slice(start, start + REPOSITORY_SEARCH_CHUNK);
+        reads.push(() => readTogether(chunk));
+      }
+    }
+    const batches = (await mapConcurrent(reads, REPOSITORY_CONCURRENCY, (read) => read())).flat();
+    const nextCursors = {};
+    for (const batch of batches) {
+      if (batch.nextCursor !== null) nextCursors[batch.key] = batch.nextCursor;
+    }
+    return {
+      viewers,
+      providers,
+      entries: batches.flatMap((batch) => batch.entries).toSorted((left, right) => right.updatedAt.localeCompare(left.updatedAt)),
+      errors: [...unreadable, ...batches.flatMap((batch) => batch.errors)],
+      truncated: batches.some((batch) => batch.truncated),
+      nextCursors
+    };
+  };
+  const detailUncached = async (input) => {
+    const project = await requireProject(input);
+    const [changeRequest, viewer] = await Promise.all([
+      project.api.getChangeRequest(changeRequestRef(project, input)).catch((error) => {
+        throw toPullRequestError("detail", error, project.api.kind, project.host);
+      }),
+      viewerOf(project)
+    ]);
+    return {
+      provider: project.api.kind,
+      capabilities: project.api.capabilities,
+      projectId: project.projectId,
+      projectTitle: project.projectTitle,
+      workspaceRoot: project.workspaceRoot,
+      repository: project.repository,
+      number: changeRequest.number,
+      title: changeRequest.title,
+      body: changeRequest.body,
+      url: changeRequest.url,
+      author: changeRequest.author,
+      state: changeRequest.state,
+      isDraft: changeRequest.isDraft,
+      mergeability: changeRequest.mergeability,
+      additions: changeRequest.additions,
+      deletions: changeRequest.deletions,
+      changedFiles: changeRequest.changedFiles,
+      headBranch: changeRequest.headBranch,
+      baseBranch: changeRequest.baseBranch,
+      createdAt: changeRequest.createdAt,
+      updatedAt: changeRequest.updatedAt,
+      mergedAt: changeRequest.mergedAt,
+      closedAt: changeRequest.closedAt,
+      reviewers: changeRequest.reviewers,
+      labels: changeRequest.labels,
+      checks: changeRequest.checks,
+      mergeCapabilities: changeRequest.mergeCapabilities,
+      viewerPermissions: changeRequest.viewerPermissions,
+      ...viewer === null || viewer.trim().length === 0 ? {} : { viewer },
+      ...changeRequest.baseComparison === void 0 ? {} : { baseComparison: changeRequest.baseComparison },
+      ...changeRequest.behindBy === void 0 ? {} : { behindBy: changeRequest.behindBy },
+      ...changeRequest.autoMergeEnabled === void 0 ? {} : { autoMergeEnabled: changeRequest.autoMergeEnabled }
+    };
+  };
+  const activityUncached = async (input) => {
+    const project = await requireProject(input);
+    const activity2 = await project.api.getChangeRequestActivity(changeRequestRef(project, input)).catch((error) => {
+      throw toPullRequestError("activity", error, project.api.kind, project.host);
+    });
+    return {
+      ...activity2.author === void 0 ? {} : { author: activity2.author },
+      ...activity2.reviewers === void 0 ? {} : { reviewers: activity2.reviewers },
+      comments: activity2.comments,
+      commentCount: activity2.commentCount,
+      commentsTruncated: activity2.commentsTruncated,
+      reviewThreads: activity2.reviewThreads,
+      commits: activity2.commits,
+      ...activity2.reactions === void 0 ? {} : { reactions: activity2.reactions }
+    };
+  };
+  const threadComments = async (input) => {
+    const project = await requireProject(input);
+    const read = project.api.getReviewThreadComments;
+    if (read === void 0) {
+      throw new PullRequestOperationFailed({
+        operation: "threadComments",
+        detail: "This host does not page review thread comments."
+      });
+    }
+    return read({
+      ...changeRequestRef(project, input),
+      threadId: input.threadId,
+      cursor: input.cursor
+    }).catch((error) => {
+      throw toPullRequestError("threadComments", error, project.api.kind, project.host);
+    });
+  };
+  const diffUncached = async (input) => {
+    const project = await requireProject(input);
+    if (!project.api.capabilities.diff) {
+      throw new PullRequestOperationFailed({
+        operation: "diff",
+        detail: "This host cannot provide a diff for a change request."
+      });
+    }
+    return project.api.getDiff({
+      ...changeRequestRef(project, input),
+      ...input.cursor === void 0 ? {} : { cursor: input.cursor },
+      ...input.commit === void 0 ? {} : { commit: input.commit }
+    }).catch((error) => {
+      throw toPullRequestError("diff", error, project.api.kind, project.host);
+    });
+  };
+  const diffFileContents = async (input) => {
+    const project = await requireProject(input);
+    const read = project.api.getDiffFileContents;
+    if (!project.api.capabilities.diff || read === void 0) {
+      throw new PullRequestOperationFailed({
+        operation: "diffFileContents",
+        detail: "This host cannot expand unchanged pull request lines."
+      });
+    }
+    return read({
+      ...changeRequestRef(project, input),
+      ...input.commit === void 0 ? {} : { commit: input.commit },
+      changeType: input.changeType,
+      oldPath: input.oldPath,
+      newPath: input.newPath
+    }).catch((error) => {
+      throw toPullRequestError("diffFileContents", error, project.api.kind, project.host);
+    });
+  };
+  const listStatsUncached = async (input) => {
+    if (input.refs.length === 0) return { stats: [] };
+    const { supported } = await workspace({});
+    const byProject = new Map(supported.map((project) => [project.projectId, project]));
+    const wanted = /* @__PURE__ */ new Map();
+    for (const ref of input.refs) {
+      const project = byProject.get(ref.projectId);
+      if (project === void 0 || project.api.listChangeRequestStats === void 0 || project.repository.toLowerCase() !== ref.repository.trim().toLowerCase()) {
+        continue;
+      }
+      wanted.set(`${project.projectId} ${ref.number}`, { project, number: ref.number });
+    }
+    const byHost = /* @__PURE__ */ new Map();
+    for (const entry of wanted.values()) {
+      const held = byHost.get(entry.project.host);
+      if (held === void 0) byHost.set(entry.project.host, [entry]);
+      else held.push(entry);
+    }
+    const stats = await mapConcurrent(
+      [...byHost.values()],
+      REPOSITORY_CONCURRENCY,
+      async (entries) => {
+        const first = entries[0];
+        const readStats = first.project.api.listChangeRequestStats;
+        if (readStats === void 0) return [];
+        const projectsByRepository = new Map(
+          entries.map((entry) => [
+            `${entry.project.repository.toLowerCase()} ${entry.number}`,
+            entry.project
+          ])
+        );
+        try {
+          const read = await readStats({
+            cwd: first.project.workspaceRoot,
+            host: first.project.host,
+            changeRequests: entries.map((entry) => ({
+              repository: entry.project.repository,
+              number: entry.number
+            }))
+          });
+          return read.flatMap((stat) => {
+            const project = projectsByRepository.get(
+              `${stat.repository.toLowerCase()} ${stat.number}`
+            );
+            return project === void 0 ? [] : [
+              {
+                projectId: project.projectId,
+                repository: project.repository,
+                number: stat.number,
+                additions: stat.additions,
+                deletions: stat.deletions
+              }
+            ];
+          });
+        } catch {
+          return [];
+        }
+      }
+    );
+    return { stats: stats.flat() };
+  };
+  let epochCounter = 0;
+  let listingsEpoch = 0;
+  const refEpochs = /* @__PURE__ */ new Map();
+  const refScope = (ref) => `${ref.projectId} ${ref.repository} ${ref.number}`;
+  const refEpoch = (ref) => refEpochs.get(refScope(ref)) ?? 0;
+  const bumpRefEpoch = (ref) => {
+    const scope = refScope(ref);
+    if (!refEpochs.has(scope) && refEpochs.size >= REF_EPOCH_CAPACITY) {
+      const oldest = refEpochs.keys().next().value;
+      if (oldest !== void 0) refEpochs.delete(oldest);
+    }
+    refEpochs.set(scope, ++epochCounter);
+  };
+  const listCache = createCache({
+    capacity: LIST_CACHE_CAPACITY,
+    ttlMs: () => LIST_CACHE_TTL_MS,
+    now
+  });
+  const detailCache = createCache({
+    capacity: DETAIL_CACHE_CAPACITY,
+    ttlMs: () => DETAIL_CACHE_TTL_MS,
+    now
+  });
+  const activityCache = createCache({
+    capacity: DETAIL_CACHE_CAPACITY,
+    ttlMs: () => DETAIL_CACHE_TTL_MS,
+    now
+  });
+  const diffCache = createCache({
+    capacity: DIFF_CACHE_CAPACITY,
+    // commit 的 diff 内容寻址，活得比整份 diff 久。
+    ttlMs: (key) => JSON.parse(key)[5] === null ? DIFF_CACHE_TTL_MS : COMMIT_DIFF_CACHE_TTL_MS,
+    now
+  });
+  const listStatsCache = createCache({
+    capacity: LIST_STATS_CACHE_CAPACITY,
+    ttlMs: () => LIST_STATS_CACHE_TTL_MS,
+    now
+  });
+  const staleDiff = createStaleWindow({
+    capacity: DIFF_CACHE_CAPACITY,
+    staleMs: DIFF_STALE_WINDOW_MS,
+    now,
+    ...options.onRefreshFailure === void 0 ? {} : { onRefreshFailure: options.onRefreshFailure }
+  });
+  const refKey = (ref) => JSON.stringify([refEpoch(ref), ref.projectId, ref.repository, ref.number]);
+  const list = (input) => {
+    const key = JSON.stringify([
+      listingsEpoch,
+      input.state,
+      input.involvement ?? null,
+      // 按位置写，所以同一组筛选无论记录怎么拼出来都是同一个键。
+      input.filters === void 0 ? null : [
+        input.filters.draft ?? null,
+        input.filters.review ?? null,
+        input.filters.checks ?? null,
+        input.filters.author ?? null,
+        input.filters.labels ?? null,
+        input.filters.excludedLabels ?? null
+      ],
+      input.projectId ?? null,
+      input.projectIds === void 0 ? null : [...input.projectIds].sort(),
+      input.host ?? null,
+      input.limit ?? null,
+      input.query ?? null,
+      input.cursors === void 0 ? null : Object.entries(input.cursors).toSorted(([left], [right]) => left.localeCompare(right))
+    ]);
+    return listCache.get(key, () => listUncached(input));
+  };
+  const listStats = (input) => {
+    if (input.refs.length === 0) return Promise.resolve({ stats: [] });
+    const key = JSON.stringify([
+      listingsEpoch,
+      input.refs.map((ref) => [ref.projectId, ref.repository, ref.number]).toSorted(
+        (left, right) => `${left[0]} ${left[1]} ${left[2]}`.localeCompare(`${right[0]} ${right[1]} ${right[2]}`)
+      )
+    ]);
+    return listStatsCache.get(key, () => listStatsUncached(input));
+  };
+  const detail = (input) => detailCache.get(refKey(input), () => detailUncached(input));
+  const activity = (input) => activityCache.get(refKey(input), () => activityUncached(input));
+  const diff = (input) => {
+    const key = JSON.stringify([
+      refEpoch(input),
+      input.projectId,
+      input.repository,
+      input.number,
+      input.cursor ?? null,
+      input.commit ?? null
+    ]);
+    return staleDiff.get(key, () => diffCache.get(key, () => diffUncached(input)));
+  };
+  const invalidate = (input) => {
+    if (input.reference === void 0) {
+      listingsEpoch = ++epochCounter;
+      viewersByHost.clear();
+      return Promise.resolve(null);
+    }
+    bumpRefEpoch(input.reference);
+    return Promise.resolve(null);
+  };
+  const afterMutation = (ref) => {
+    bumpRefEpoch(ref);
+    listingsEpoch = ++epochCounter;
+    return null;
+  };
+  const reviewerCandidates = async (input) => {
+    const project = await requireProject(input);
+    if (!project.api.capabilities.reviewers.listCandidates) {
+      throw new PullRequestOperationFailed({
+        operation: "reviewerCandidates",
+        detail: "This host cannot say who may review a change request."
+      });
+    }
+    const viewer = await viewerPermissionsOf(project, input, "reviewerCandidates");
+    if (!viewer.requestReviewers) {
+      throw new PullRequestOperationFailed({
+        operation: "reviewerCandidates",
+        detail: REVIEWER_REQUEST_REFUSAL
+      });
+    }
+    return project.api.listReviewerCandidates(changeRequestRef(project, input)).catch((error) => {
+      throw toPullRequestError("reviewerCandidates", error, project.api.kind, project.host);
+    });
+  };
+  const runAction3 = async (input) => {
+    const project = await requireProject(input);
+    if (!project.api.capabilities.actions.includes(input.action)) {
+      throw new PullRequestOperationFailed({
+        operation: "runAction",
+        detail: `This host cannot ${input.action} a change request.`
+      });
+    }
+    if (input.mergeMethod !== void 0 && !project.api.capabilities.mergeMethods.includes(input.mergeMethod)) {
+      throw new PullRequestOperationFailed({
+        operation: "runAction",
+        detail: `This host cannot merge with the ${input.mergeMethod} strategy.`
+      });
+    }
+    if (input.updateMethod !== void 0 && !(project.api.capabilities.updateMethods ?? []).includes(input.updateMethod)) {
+      throw new PullRequestOperationFailed({
+        operation: "runAction",
+        detail: `This host cannot update a branch by ${input.updateMethod}.`
+      });
+    }
+    const viewer = await viewerPermissionsOf(project, input, "runAction");
+    if (!viewer.actions.includes(input.action)) {
+      throw new PullRequestOperationFailed({
+        operation: "runAction",
+        detail: ACTION_ACCESS_REFUSALS[input.action]
+      });
+    }
+    if (input.updateMethod !== void 0 && !(viewer.updateMethods ?? []).includes(input.updateMethod)) {
+      throw new PullRequestOperationFailed({
+        operation: "runAction",
+        detail: ACTION_ACCESS_REFUSALS["update-branch"]
+      });
+    }
+    await project.api.runAction({
+      ...changeRequestRef(project, input),
+      action: input.action,
+      ...input.mergeMethod === void 0 ? {} : { mergeMethod: input.mergeMethod },
+      ...input.updateMethod === void 0 ? {} : { updateMethod: input.updateMethod }
+    }).catch((error) => {
+      throw toPullRequestError("runAction", error, project.api.kind, project.host);
+    });
+    if (input.action === "merge") {
+      options.onMerged?.({
+        projectId: input.projectId,
+        repository: project.repository,
+        number: input.number,
+        host: project.host
+      });
+    }
+    return afterMutation(input);
+  };
+  const update = async (input) => {
+    const project = await requireProject(input);
+    const rewrite = project.api.updateChangeRequest;
+    if (project.api.capabilities.edit?.changeRequest !== true || rewrite === void 0) {
+      throw new PullRequestOperationFailed({
+        operation: "update",
+        detail: "This host cannot rewrite a change request."
+      });
+    }
+    if (input.title === void 0 && input.body === void 0) {
+      throw new PullRequestOperationFailed({ operation: "update", detail: "Nothing was changed." });
+    }
+    await rewrite({
+      ...changeRequestRef(project, input),
+      ...input.title === void 0 ? {} : { title: input.title },
+      ...input.body === void 0 ? {} : { body: input.body }
+    }).catch((error) => {
+      throw toPullRequestError("update", error, project.api.kind, project.host);
+    });
+    return afterMutation(input);
+  };
+  const requestReviewers = async (input) => {
+    const project = await requireProject(input);
+    if (!project.api.capabilities.reviewers.request) {
+      throw new PullRequestOperationFailed({
+        operation: "requestReviewers",
+        detail: "This host cannot ask somebody for a review."
+      });
+    }
+    const viewer = await viewerPermissionsOf(project, input, "requestReviewers");
+    if (!viewer.requestReviewers) {
+      throw new PullRequestOperationFailed({
+        operation: "requestReviewers",
+        detail: REVIEWER_REQUEST_REFUSAL
+      });
+    }
+    await project.api.setReviewerRequest({
+      ...changeRequestRef(project, input),
+      reviewers: input.reviewers,
+      requested: input.requested
+    }).catch((error) => {
+      throw toPullRequestError("requestReviewers", error, project.api.kind, project.host);
+    });
+    return afterMutation(input);
+  };
+  const comment3 = async (input) => {
+    if (input.body.trim().length === 0) {
+      throw new PullRequestOperationFailed({
+        operation: "comment",
+        detail: "A comment cannot be empty."
+      });
+    }
+    const project = await requireProject(input);
+    if (!project.api.capabilities.comment) {
+      throw new PullRequestOperationFailed({
+        operation: "comment",
+        detail: "This host cannot post a comment on a change request."
+      });
+    }
+    const viewer = await viewerPermissionsOf(project, input, "comment");
+    if (!viewer.comment) {
+      throw new PullRequestOperationFailed({
+        operation: "comment",
+        detail: "You need write access on this repository to comment on a change request."
+      });
+    }
+    await project.api.comment({ ...changeRequestRef(project, input), body: input.body }).catch((error) => {
+      throw toPullRequestError("comment", error, project.api.kind, project.host);
+    });
+    return afterMutation(input);
+  };
+  const updateComment3 = async (input) => {
+    if (input.body.trim().length === 0) {
+      throw new PullRequestOperationFailed({
+        operation: "updateComment",
+        detail: "A comment cannot be empty."
+      });
+    }
+    const project = await requireProject(input);
+    const rewrite = project.api.updateComment;
+    if (project.api.capabilities.edit?.comment !== true || rewrite === void 0) {
+      throw new PullRequestOperationFailed({
+        operation: "updateComment",
+        detail: "This host cannot rewrite a comment."
+      });
+    }
+    await rewrite({
+      ...changeRequestRef(project, input),
+      commentId: input.commentId,
+      kind: input.kind,
+      body: input.body
+    }).catch((error) => {
+      throw toPullRequestError("updateComment", error, project.api.kind, project.host);
+    });
+    return afterMutation(input);
+  };
+  const submitReview3 = async (input) => {
+    const project = await requireProject(input);
+    const review = project.api.capabilities.review;
+    const refuse = (detail2) => {
+      throw new PullRequestOperationFailed({ operation: "submitReview", detail: detail2 });
+    };
+    if (!review.verdicts.includes(input.verdict)) {
+      refuse(`This host cannot ${VERDICT_LABELS[input.verdict]} a change request.`);
+    }
+    if (input.comments.length > 0 && !review.inlineComment) {
+      refuse("This host cannot comment on a line of a change request.");
+    }
+    if (input.verdict !== "approve" && input.body.trim().length === 0 && input.comments.length === 0) {
+      refuse("A review needs a summary or at least one comment.");
+    }
+    const viewer = await viewerPermissionsOf(project, input, "submitReview");
+    if (!viewer.verdicts.includes(input.verdict)) {
+      refuse(
+        `You need write access on this repository to ${VERDICT_LABELS[input.verdict]} a change request.`
+      );
+    }
+    if (input.comments.length > 0 && !viewer.comment) {
+      refuse("You need write access on this repository to comment on a line of a change request.");
+    }
+    await project.api.submitReview({
+      ...changeRequestRef(project, input),
+      verdict: input.verdict,
+      body: input.body,
+      comments: input.comments
+    }).catch((error) => {
+      throw toPullRequestError("submitReview", error, project.api.kind, project.host);
+    });
+    return afterMutation(input);
+  };
+  const replyToThread3 = async (input) => {
+    if (input.body.trim().length === 0) {
+      throw new PullRequestOperationFailed({
+        operation: "replyToThread",
+        detail: "A reply cannot be empty."
+      });
+    }
+    const project = await requireProject(input);
+    if (!project.api.capabilities.review.reply) {
+      throw new PullRequestOperationFailed({
+        operation: "replyToThread",
+        detail: "This host cannot reply to a review conversation."
+      });
+    }
+    const viewer = await viewerPermissionsOf(project, input, "replyToThread");
+    if (!viewer.comment) {
+      throw new PullRequestOperationFailed({
+        operation: "replyToThread",
+        detail: "You need write access on this repository to reply to a review conversation."
+      });
+    }
+    await project.api.replyToThread({
+      ...changeRequestRef(project, input),
+      threadId: input.threadId,
+      body: input.body
+    }).catch((error) => {
+      throw toPullRequestError("replyToThread", error, project.api.kind, project.host);
+    });
+    return afterMutation(input);
+  };
+  const setThreadResolution3 = async (input) => {
+    const project = await requireProject(input);
+    if (!project.api.capabilities.review.resolve) {
+      throw new PullRequestOperationFailed({
+        operation: "setThreadResolution",
+        detail: "This host cannot resolve a review conversation."
+      });
+    }
+    const viewer = await viewerPermissionsOf(project, input, "setThreadResolution");
+    if (!viewer.resolve) {
+      throw new PullRequestOperationFailed({
+        operation: "setThreadResolution",
+        detail: "You need write access on this repository, or to have opened this change request, to resolve a review conversation."
+      });
+    }
+    await project.api.setThreadResolution({
+      ...changeRequestRef(project, input),
+      threadId: input.threadId,
+      resolved: input.resolved
+    }).catch((error) => {
+      throw toPullRequestError("setThreadResolution", error, project.api.kind, project.host);
+    });
+    return afterMutation(input);
+  };
+  const setReaction3 = async (input) => {
+    const project = await requireProject(input);
+    if (project.api.capabilities.reactions !== true) {
+      throw new PullRequestOperationFailed({
+        operation: "setReaction",
+        detail: "This host has no reactions."
+      });
+    }
+    await project.api.setReaction({
+      ...changeRequestRef(project, input),
+      ...input.subjectId === void 0 ? {} : { subjectId: input.subjectId },
+      content: input.content,
+      reacted: input.reacted
+    }).catch((error) => {
+      throw toPullRequestError("setReaction", error, project.api.kind, project.host);
+    });
+    return afterMutation(input);
+  };
+  const act = (input) => {
+    switch (input.op) {
+      case "runAction":
+        return runAction3(input);
+      case "update":
+        return update(input);
+      case "requestReviewers":
+        return requestReviewers(input);
+    }
+  };
+  const converse = (input) => {
+    switch (input.op) {
+      case "comment":
+        return comment3(input);
+      case "updateComment":
+        return updateComment3(input);
+      case "submitReview":
+        return submitReview3(input);
+      case "replyToThread":
+        return replyToThread3(input);
+      case "setThreadResolution":
+        return setThreadResolution3(input);
+      case "setReaction":
+        return setReaction3(input);
+    }
+  };
+  return {
+    list,
+    listStats,
+    detail,
+    activity,
+    threadComments,
+    diff,
+    diffFileContents,
+    reviewerCandidates,
+    invalidate,
+    act,
+    converse
+  };
+};
+
+// src/index.ts
+var as = (payload) => payload;
+var DIFF_CHUNK_CHARS = 256 * 1024;
+var DIFF_STREAM_ITEM_SCHEMA = {
+  oneOf: [
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "text"],
+      properties: { kind: { const: "chunk" }, text: { type: "string" } }
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "truncated", "nextCursor"],
+      properties: {
+        kind: { const: "done" },
+        truncated: { type: "boolean" },
+        nextCursor: { type: ["string", "null"], minLength: 1 },
+        omittedFileStats: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["path", "additions", "deletions"],
+            properties: {
+              path: { type: "string", minLength: 1 },
+              additions: { type: "number" },
+              deletions: { type: "number" }
+            }
+          }
+        }
+      }
+    }
+  ]
+};
+var index_default = definePlugin({
+  id: "pull-requests",
+  apiVersion: 2,
+  activate: (ctx) => {
+    const service = createPullRequestService({
+      listProjects: () => ctx.projections.listProjects(),
+      apis: [gitlabApi(ctx), githubApi(ctx)],
+      onRefreshFailure: (error) => ctx.log.warn("stale diff refresh failed", { detail: String(error) }),
+      // 编排事件流里没有「合并了」这个转移，所以这条触发事件只能从这里报。不 await：
+      // 合并已经在主机上发生了，报不出去不该让调用方以为它没发生。
+      onMerged: (merged) => {
+        void ctx.events.emit("pull-request.merged", {
+          projectId: merged.projectId,
+          summary: `${merged.repository} change request ${merged.number} merged on ${merged.host}.`,
+          data: {
+            repository: merged.repository,
+            number: merged.number,
+            host: merged.host
+          }
+        }).catch((error) => {
+          ctx.log.warn("the merged event could not be emitted", { detail: String(error) });
+        });
+      }
+    });
+    const page = (name, description, scope, payloadContract, resultContract, handle) => {
+      ctx.command({
+        name,
+        description,
+        scope,
+        payloadContract,
+        ...resultContract === null ? {} : { resultContract },
+        handle
+      });
+    };
+    page(
+      "list",
+      "Every change request the workspace's repositories have, newest update first.",
+      "read",
+      "PullRequestListInput",
+      "PullRequestListResult",
+      (payload) => service.list(as(payload))
+    );
+    page(
+      "listStats",
+      "The line counts the listing left out, for rows already on the page.",
+      "read",
+      "PullRequestListStatsInput",
+      "PullRequestListStatsResult",
+      (payload) => service.listStats(as(payload))
+    );
+    page(
+      "detail",
+      "One change request with the repository's merge strategies and this viewer's permissions.",
+      "read",
+      "PullRequestRef",
+      "PullRequestDetail",
+      (payload) => service.detail(as(payload))
+    );
+    page(
+      "activity",
+      "Comments, line threads, commits and reactions, read apart from the detail.",
+      "read",
+      "PullRequestRef",
+      "PullRequestActivity",
+      (payload) => service.activity(as(payload))
+    );
+    page(
+      "threadComments",
+      "The rest of one review thread, after a reader asks to carry on reading it.",
+      "read",
+      "PullRequestThreadCommentsInput",
+      "PullRequestThreadCommentsResult",
+      (payload) => service.threadComments(as(payload))
+    );
+    ctx.stream({
+      name: "diff",
+      description: "One slice of the change request patch, or of one commit of it.",
+      scope: "read",
+      payloadContract: "PullRequestDiffInput",
+      itemSchema: DIFF_STREAM_ITEM_SCHEMA,
+      handle: async (payload, emit, signal) => {
+        const slice = await service.diff(as(payload));
+        for (let offset = 0; offset < slice.patch.length; offset += DIFF_CHUNK_CHARS) {
+          if (signal.aborted) return;
+          emit({ kind: "chunk", text: slice.patch.slice(offset, offset + DIFF_CHUNK_CHARS) });
+        }
+        if (signal.aborted) return;
+        emit({
+          kind: "done",
+          truncated: slice.truncated,
+          nextCursor: slice.nextCursor,
+          ...slice.omittedFileStats === void 0 ? {} : { omittedFileStats: slice.omittedFileStats }
+        });
+      }
+    });
+    page(
+      "diffText",
+      "The whole change request patch, or of one commit of it.",
+      "read",
+      "PullRequestDiffInput",
+      "PullRequestDiffResult",
+      (payload) => service.diff(as(payload))
+    );
+    page(
+      "diffFileContents",
+      "The whole old and new file at the revisions the patch was made from.",
+      "read",
+      "PullRequestDiffFileContentsInput",
+      "PullRequestDiffFileContentsResult",
+      (payload) => service.diffFileContents(as(payload))
+    );
+    page(
+      "reviewerCandidates",
+      "The people this change request may be sent to, with those already asked marked.",
+      "read",
+      "PullRequestRef",
+      "PullRequestReviewerCandidateList",
+      (payload) => service.reviewerCandidates(as(payload))
+    );
+    page(
+      "invalidate",
+      "Forget what is cached, so the next read asks the host again.",
+      "read",
+      "PullRequestInvalidateInput",
+      null,
+      (payload) => service.invalidate(as(payload))
+    );
+    page(
+      "act",
+      "Merges, closes, rewrites, or asks for a review on a change request.",
+      "operate",
+      "PullRequestActRequest",
+      null,
+      (payload) => service.act(as(payload))
+    );
+    page(
+      "converse",
+      "Comments, reviews, replies, resolves, or reacts on a change request.",
+      "operate",
+      "PullRequestConverseRequest",
+      null,
+      (payload) => service.converse(as(payload))
+    );
+    ctx.command({
+      name: "workspaceProjects",
+      description: "Git repositories in this machine's workspace, with their remote identity.",
+      scope: "read",
+      payloadSchema: { type: "object", properties: {}, additionalProperties: false },
+      resultSchema: {
+        type: "object",
+        additionalProperties: false,
+        required: ["projects"],
+        properties: {
+          projects: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              required: ["projectId", "title", "workspaceRoot"],
+              properties: {
+                projectId: { type: "string", minLength: 1 },
+                title: { type: "string" },
+                workspaceRoot: { type: "string" },
+                repositoryIdentity: {
+                  type: ["object", "null"],
+                  additionalProperties: false,
+                  properties: {
+                    provider: { type: "string" },
+                    canonicalKey: { type: "string" },
+                    remoteName: { type: "string" },
+                    remoteUrl: { type: "string" },
+                    displayName: { type: "string" },
+                    owner: { type: "string" },
+                    name: { type: "string" },
+                    rootPath: { type: "string" }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      handle: async () => {
+        const projects = await ctx.projections.listProjects();
+        return {
+          projects: projects.map((project) => ({
+            projectId: project.projectId,
+            title: project.title,
+            workspaceRoot: project.workspaceRoot,
+            repositoryIdentity: project.repositoryIdentity
+          }))
+        };
+      }
+    });
+    ctx.settingsCard({
+      title: "Pull requests",
+      description: "Pull and merge requests are read and written straight over the host API, with a token you paste here.",
+      fields: [
+        {
+          key: "gitlabHost",
+          kind: "text",
+          label: "GitLab host",
+          description: "Fill in the domain of a self-managed instance.",
+          placeholder: "gitlab.com"
+        },
+        {
+          key: "gitlabToken",
+          kind: "password",
+          label: "GitLab token",
+          // 不标 required：两台主机共用这一张卡，只用 GitHub 的人不该被一枚 GitLab
+          // token 卡住。缺 token 的那一侧在命令里报 unauthenticated。
+          description: "A personal access token with the `api` scope."
+        },
+        {
+          key: "githubHost",
+          kind: "text",
+          label: "GitHub host",
+          description: "Fill in the domain of a GitHub Enterprise install.",
+          placeholder: "github.com"
+        },
+        {
+          key: "githubToken",
+          kind: "password",
+          label: "GitHub token",
+          description: "A personal access token that may read and write the repositories you review. The `repo` scope is enough; add `read:org` to also see team reviewers."
+        }
+      ]
+    });
+    ctx.log.info("pull requests plugin active", { hosts: ["gitlab", "github"] });
+  }
+});
+export {
+  index_default as default
+};