forges 0.0.0 → 0.1.0

package/dist/azure-devops-DwQvL4TV.mjs

@@ -0,0 +1,1355 @@
+import { C as requireIssueOrPull, Ct as MergeMethodRequiredError, D as syntheticReview, E as summariseChecks, O as toDate, Pt as toMergeError, S as phased, T as resolveToken, _t as ForgeError, b as mergeCommitMessage, f as getManyConcurrently, ft as toFileContent, j as toWarning, jt as UnsupportedOperationError, n as perKind, r as verb, t as defineForgeProvider, v as memo, w as requireThread, wt as NotFoundError } from "./define-D3yEXtKK.mjs";
+import { c as timingSafeEqual, n as headerValue, t as bodyText } from "./crypto-CQNEyYHD.mjs";
+import { i as refEvent } from "./webhooks-rn9-8lxT.mjs";
+//#region src/azure-devops/normalise.ts
+const FORGE = "azure-devops";
+function toActor(instance, identity) {
+	if (!identity) return;
+	const login = identity.uniqueName ?? identity.displayName ?? identity.id;
+	return {
+		forge: FORGE,
+		instance,
+		login,
+		id: identity.id,
+		name: identity.displayName,
+		avatarUrl: identity.imageUrl,
+		typeRaw: identity.isContainer ? "group" : "user",
+		isBotHint: /Build Service|Project Collection Build Service/.test(identity.displayName ?? "") || /^Build\\/.test(identity.uniqueName ?? "")
+	};
+}
+/** Repositories live in a project in an organization; the owner is `org/project`. */
+function toRepoRef(instance, organization, repo) {
+	return {
+		forge: FORGE,
+		instance,
+		owner: `${organization}/${repo.project.name}`,
+		name: repo.name,
+		externalId: repo.id
+	};
+}
+/** Work items belong to a project rather than a repository. */
+function projectRef(instance, organization, project) {
+	return {
+		forge: FORGE,
+		instance,
+		owner: `${organization}/${project}`,
+		name: "",
+		kind: "namespace"
+	};
+}
+function toRepo(instance, organization, raw) {
+	return {
+		ref: toRepoRef(instance, organization, raw),
+		defaultBranch: raw.defaultBranch?.replace(/^refs\/heads\//, ""),
+		visibility: "private",
+		isFork: raw.isFork ?? false,
+		isArchived: raw.isDisabled ?? false,
+		parent: raw.parentRepository?.project ? toRepoRef(instance, organization, {
+			...raw.parentRepository,
+			project: raw.parentRepository.project
+		}) : void 0,
+		topics: [],
+		url: raw.webUrl,
+		cloneUrls: {
+			https: raw.remoteUrl,
+			ssh: raw.sshUrl
+		},
+		raw
+	};
+}
+const VOTES = {
+	10: "approved",
+	5: "approved",
+	0: "pending",
+	[-5]: "changes_requested",
+	[-10]: "changes_requested"
+};
+function toReviewer(instance, raw) {
+	return {
+		actor: toActor(instance, raw),
+		state: VOTES[raw.vote] ?? "unknown",
+		stateRaw: `vote:${raw.vote}`,
+		...raw.isContainer ? { isTeam: true } : {}
+	};
+}
+const branch = (ref) => ref.replace(/^refs\/heads\//, "");
+function toPullThread(ref, raw) {
+	const instance = ref.instance;
+	const state = raw.status === "active" ? "open" : raw.status === "completed" ? "merged" : raw.status === "abandoned" ? "closed" : "unknown";
+	return {
+		ref: {
+			...ref,
+			kind: "pull_request",
+			number: String(raw.pullRequestId),
+			externalId: raw.artifactId
+		},
+		kind: "pull_request",
+		title: raw.title,
+		body: raw.description || void 0,
+		state,
+		stateRaw: raw.status,
+		isDraft: raw.isDraft ?? false,
+		author: toActor(instance, raw.createdBy),
+		assignees: [],
+		reviewers: (raw.reviewers ?? []).map((reviewer) => toReviewer(instance, reviewer)),
+		labels: (raw.labels ?? []).filter((label) => label.active !== false).map((label) => ({ name: label.name })),
+		url: raw._links?.web?.href,
+		createdAt: toDate(raw.creationDate),
+		closedAt: toDate(raw.closedDate),
+		lastActivityAt: toDate(raw.closedDate ?? raw.creationDate),
+		branches: {
+			head: {
+				ref: branch(raw.sourceRefName),
+				sha: raw.lastMergeSourceCommit?.commitId
+			},
+			base: {
+				ref: branch(raw.targetRefName),
+				sha: raw.lastMergeTargetCommit?.commitId
+			},
+			mergeCommitSha: raw.status === "completed" ? raw.lastMergeCommit?.commitId : void 0
+		},
+		raw
+	};
+}
+const field = (item, name) => item.fields[name];
+/** State categories `Completed` and `Removed` are closed; every other category is open. */
+function toWorkItemThread(ref, raw, category) {
+	const instance = ref.instance;
+	const assignee = field(raw, "System.AssignedTo");
+	const tags = field(raw, "System.Tags");
+	const state = category === void 0 ? "unknown" : category === "Completed" || category === "Removed" ? "closed" : "open";
+	return {
+		ref: {
+			...ref,
+			kind: "issue",
+			number: String(raw.id),
+			typeRaw: field(raw, "System.WorkItemType")
+		},
+		kind: "issue",
+		title: field(raw, "System.Title") ?? "",
+		body: field(raw, "System.Description"),
+		state,
+		stateRaw: field(raw, "System.State"),
+		stateReason: field(raw, "System.Reason"),
+		isDraft: false,
+		author: toActor(instance, field(raw, "System.CreatedBy")),
+		assignees: assignee ? [toActor(instance, assignee)] : [],
+		reviewers: [],
+		labels: (tags ?? "").split(";").map((tag) => tag.trim()).filter(Boolean).map((name) => ({ name })),
+		url: raw._links?.html?.href,
+		createdAt: toDate(field(raw, "System.CreatedDate")),
+		updatedAt: toDate(field(raw, "System.ChangedDate")),
+		closedAt: toDate(field(raw, "Microsoft.VSTS.Common.ClosedDate")),
+		lastActivityAt: toDate(field(raw, "System.ChangedDate")),
+		commentCount: field(raw, "System.CommentCount"),
+		raw
+	};
+}
+/** Conversation threads have no file anchor and carry text comments; system threads record votes and updates. */
+function isConversationThread(thread) {
+	return !thread.threadContext?.filePath && thread.comments.some((comment) => comment.commentType !== "system");
+}
+/** Pull request comment ids are unique within a thread only, so a comment id is `<thread>/<comment>`. */
+function commentId(thread, comment) {
+	return `${thread.id}/${comment.id}`;
+}
+function toPullComment(ref, thread, raw) {
+	return {
+		ref: {
+			forge: FORGE,
+			instance: ref.instance,
+			thread: ref,
+			id: commentId(thread, raw)
+		},
+		body: raw.content ?? "",
+		author: toActor(ref.instance, raw.author),
+		createdAt: toDate(raw.publishedDate),
+		updatedAt: toDate(raw.lastUpdatedDate),
+		...thread.status && { thread: {
+			id: String(thread.id),
+			resolved: thread.status !== "active" && thread.status !== "pending"
+		} },
+		raw
+	};
+}
+function toThreadEvents(ref, thread) {
+	return thread.comments.filter((comment) => !comment.isDeleted).map((comment) => {
+		const actor = toActor(ref.instance, comment.author);
+		const system = comment.commentType === "system";
+		const kind = thread.properties?.CodeReviewThreadType?.$value === "VoteUpdate" ? "review" : system ? "other" : thread.threadContext?.filePath ? "review_comment" : "comment";
+		return {
+			forge: FORGE,
+			instance: ref.instance,
+			id: commentId(thread, comment),
+			kind,
+			kindRaw: thread.properties?.CodeReviewThreadType?.$value ?? comment.commentType,
+			summary: `${actor?.login ?? "someone"} ${system ? comment.content ?? "updated the pull request" : "commented"}`,
+			occurredAt: toDate(comment.publishedDate) ?? /* @__PURE__ */ new Date(0),
+			actor,
+			repo: ref.repo,
+			thread: ref,
+			source: "poll",
+			payload: comment
+		};
+	});
+}
+function toWorkItemComment(ref, raw) {
+	return {
+		ref: {
+			forge: FORGE,
+			instance: ref.instance,
+			thread: ref,
+			id: String(raw.id)
+		},
+		body: raw.text,
+		author: toActor(ref.instance, raw.createdBy),
+		createdAt: toDate(raw.createdDate),
+		updatedAt: toDate(raw.modifiedDate),
+		raw
+	};
+}
+function toWorkItemEvents(ref, updates, comments) {
+	const events = updates.flatMap((update) => {
+		const fields = update.fields ?? {};
+		const actor = toActor(ref.instance, update.revisedBy);
+		const kind = fields["System.State"] ? "state_change" : fields["System.AssignedTo"] ? "assignment" : fields["System.Tags"] ? "label" : void 0;
+		if (!kind || update.id === 1) return [];
+		return [{
+			forge: FORGE,
+			instance: ref.instance,
+			id: `update:${update.id}`,
+			kind,
+			kindRaw: Object.keys(fields).join(","),
+			summary: `${actor?.login ?? "someone"} changed ${kind === "state_change" ? `state to ${String(fields["System.State"]?.newValue)}` : kind === "assignment" ? "the assignee" : "the tags"}`,
+			occurredAt: toDate(update.revisedDate) ?? /* @__PURE__ */ new Date(0),
+			actor,
+			repo: ref.repo,
+			thread: ref,
+			source: "poll",
+			payload: update
+		}];
+	});
+	for (const comment of comments) {
+		const actor = toActor(ref.instance, comment.createdBy);
+		events.push({
+			forge: FORGE,
+			instance: ref.instance,
+			id: `comment:${comment.id}`,
+			kind: "comment",
+			kindRaw: "comment",
+			summary: `${actor?.login ?? "someone"} commented`,
+			occurredAt: toDate(comment.createdDate) ?? /* @__PURE__ */ new Date(0),
+			actor,
+			repo: ref.repo,
+			thread: ref,
+			source: "poll",
+			payload: comment
+		});
+	}
+	return events.sort((a, b) => a.occurredAt.getTime() - b.occurredAt.getTime());
+}
+const STATUS_STATES = {
+	notSet: "unknown",
+	pending: "pending",
+	succeeded: "success",
+	failed: "failure",
+	error: "failure",
+	notApplicable: "neutral"
+};
+function toStatusCheck(repo, raw) {
+	const state = STATUS_STATES[raw.state] ?? "unknown";
+	return {
+		ref: {
+			forge: FORGE,
+			instance: repo.instance,
+			repo,
+			id: String(raw.id),
+			type: "status"
+		},
+		name: raw.context.genre ? `${raw.context.genre}/${raw.context.name}` : raw.context.name,
+		state,
+		stateRaw: raw.state,
+		url: raw.targetUrl,
+		startedAt: toDate(raw.creationDate),
+		completedAt: state === "pending" ? void 0 : toDate(raw.updatedDate),
+		raw
+	};
+}
+const POLICY_STATES = {
+	queued: "pending",
+	running: "pending",
+	approved: "success",
+	rejected: "failure",
+	broken: "failure",
+	notApplicable: "neutral"
+};
+/** Branch policy evaluations: required reviewers, builds, linked work items and the like. Optional policies that fail are neutral. */
+function toPolicyCheck(repo, raw) {
+	const blocking = raw.configuration?.isBlocking !== false;
+	const state = POLICY_STATES[raw.status] ?? "unknown";
+	return {
+		ref: {
+			forge: FORGE,
+			instance: repo.instance,
+			repo,
+			id: raw.evaluationId,
+			type: "policy"
+		},
+		name: raw.configuration?.settings?.displayName ?? raw.configuration?.type?.displayName ?? "Policy",
+		state: state === "failure" && !blocking ? "neutral" : state,
+		stateRaw: raw.status,
+		startedAt: toDate(raw.startedDate),
+		completedAt: toDate(raw.completedDate),
+		raw
+	};
+}
+/** Azure names a change `add`, `edit`, `delete`, `rename` or a comma-joined combination. */
+function toChangedFile(raw) {
+	const path = raw.item?.path?.replace(/^\//, "") ?? "";
+	const types = raw.changeType?.split(",").map((type) => type.trim().toLowerCase()) ?? [];
+	const status = types.includes("delete") ? "removed" : types.includes("rename") ? "renamed" : types.includes("add") ? "added" : types.includes("edit") ? "modified" : "changed";
+	return {
+		path,
+		previousPath: raw.sourceServerItem?.replace(/^\//, ""),
+		status,
+		statusRaw: raw.changeType,
+		sha: raw.item?.objectId
+	};
+}
+function toCommit(repo, raw, files) {
+	const counts = raw.changeCounts;
+	return {
+		ref: {
+			forge: FORGE,
+			instance: repo.instance,
+			repo,
+			sha: raw.commitId
+		},
+		sha: raw.commitId,
+		message: raw.comment ?? "",
+		author: {
+			name: raw.author?.name,
+			email: raw.author?.email,
+			date: toDate(raw.author?.date)
+		},
+		committer: {
+			name: raw.committer?.name,
+			email: raw.committer?.email,
+			date: toDate(raw.committer?.date)
+		},
+		parents: raw.parents ?? [],
+		url: raw.remoteUrl,
+		...counts ? { stats: {
+			additions: counts.Add ?? 0,
+			deletions: counts.Delete ?? 0
+		} } : {},
+		...files ? { files } : {},
+		raw
+	};
+}
+function toBranch(raw) {
+	return {
+		name: raw.name.replace(/^refs\/heads\//, ""),
+		sha: raw.objectId ?? "",
+		url: raw.url,
+		raw
+	};
+}
+function toTag(raw) {
+	return {
+		name: raw.name.replace(/^refs\/tags\//, ""),
+		sha: raw.peeledObjectId ?? raw.objectId ?? "",
+		url: raw.url,
+		raw
+	};
+}
+function toTreeEntry(raw) {
+	return {
+		path: raw.path.replace(/^\//, ""),
+		type: raw.isFolder || raw.gitObjectType === "tree" ? "directory" : raw.gitObjectType === "commit" ? "submodule" : "file",
+		sha: raw.objectId,
+		size: raw.size
+	};
+}
+//#endregion
+//#region src/azure-devops/web.ts
+const encode = (path) => path.split("/").map(encodeURIComponent).join("/");
+const gitPath = (repo) => `/${encode(repo.owner)}/_git/${encodeURIComponent(repo.name)}`;
+function azureWeb(origin) {
+	return {
+		origin,
+		repo: (repo) => repo.kind === "namespace" ? `/${encode(repo.owner)}` : gitPath(repo),
+		thread: (ref) => {
+			if (ref.kind === "issue") return `/${encode(ref.repo.owner)}/_workitems/edit/${encodeURIComponent(ref.number)}`;
+			if (ref.kind === "pull_request") return `${gitPath(ref.repo)}/pullrequest/${encodeURIComponent(ref.number)}`;
+			return ref.kind === "commit" ? `${gitPath(ref.repo)}/commit/${encodeURIComponent(ref.number)}` : void 0;
+		},
+		file: (repo, path, at, line) => `${gitPath(repo)}?path=${encodeURIComponent(`/${path}`)}&version=GB${encodeURIComponent(at)}${line ? `&line=${line}` : ""}`,
+		compare: (repo, base, head) => `${gitPath(repo)}/branchCompare?baseVersion=GB${encodeURIComponent(base)}&targetVersion=GB${encodeURIComponent(head)}`,
+		parse: (segments, _url, from) => {
+			const [org, project, section, ...rest] = segments;
+			if (!org || !project) return;
+			const owner = `${org}/${project}`;
+			if (section === "_workitems" && rest[0] === "edit" && rest[1]) {
+				const repo = {
+					...from,
+					owner,
+					name: "",
+					kind: "namespace"
+				};
+				return {
+					repo,
+					thread: {
+						...from,
+						repo,
+						kind: "issue",
+						number: rest[1]
+					}
+				};
+			}
+			if (section !== "_git" || !rest[0]) return { repo: {
+				...from,
+				owner,
+				name: "",
+				kind: "namespace"
+			} };
+			const repo = {
+				...from,
+				owner,
+				name: rest[0]
+			};
+			const kind = rest[1] === "pullrequest" ? "pull_request" : rest[1] === "commit" ? "commit" : void 0;
+			if (!kind || !rest[2]) return { repo };
+			return {
+				repo,
+				thread: {
+					...from,
+					repo,
+					kind,
+					number: rest[2]
+				}
+			};
+		},
+		reference: (ref) => ref.kind === "issue" ? `#${ref.number}` : ref.kind === "pull_request" ? `!${ref.number}` : void 0
+	};
+}
+//#endregion
+//#region src/azure-devops/webhooks.ts
+/**
+* Service hooks carry no signature. A subscription can send basic
+* credentials, so `secret` is `username:password` and the delivery's
+* `Authorization: Basic` header must match it.
+*/
+function verifyAzureBasicAuth(delivery, secret) {
+	const key = delivery.secret ?? secret;
+	const header = headerValue(delivery.headers, "authorization");
+	if (!key || !header?.startsWith("Basic ")) return false;
+	return timingSafeEqual(header, `Basic ${btoa(key)}`);
+}
+const PULL_KINDS = {
+	"git.pullrequest.created": "state_change",
+	"git.pullrequest.merged": "state_change",
+	"git.pullrequest.updated": "other",
+	"ms.vss-code.git-pullrequest-comment-event": "comment"
+};
+function translateAzureWebhook(instance, organization, delivery) {
+	const event = JSON.parse(bodyText(delivery.body));
+	const resource = event.resource;
+	const pull = resource.pullRequest ?? (event.eventType.startsWith("git.pullrequest") ? resource : void 0);
+	const repository = pull?.repository ?? resource.repository;
+	const repo = repository?.project ? toRepoRef(instance, organization, repository) : void 0;
+	const base = {
+		forge: FORGE,
+		instance,
+		id: event.id,
+		kindRaw: event.eventType,
+		occurredAt: toDate(event.createdDate) ?? /* @__PURE__ */ new Date(),
+		repo,
+		source: "webhook",
+		payload: event
+	};
+	if (pull && repo) {
+		const thread = {
+			forge: FORGE,
+			instance,
+			repo,
+			kind: "pull_request",
+			number: String(pull.pullRequestId)
+		};
+		const comment = resource.comment;
+		const actor = toActor(instance, comment?.author ?? pull.createdBy);
+		return [{
+			...base,
+			kind: PULL_KINDS[event.eventType] ?? "other",
+			actor,
+			thread,
+			summary: event.message?.text ?? `${actor?.login ?? "someone"} ${event.eventType}`
+		}];
+	}
+	if (event.eventType.startsWith("workitem.")) {
+		const fields = resource.fields ?? resource.revision?.fields ?? {};
+		const id = String(resource.workItemId ?? resource.id);
+		const project = fields["System.TeamProject"];
+		const projectName = typeof project === "string" ? project : project?.newValue;
+		const thread = projectName ? {
+			forge: FORGE,
+			instance,
+			repo: projectRef(instance, organization, projectName),
+			kind: "issue",
+			number: id
+		} : void 0;
+		const kind = event.eventType === "workitem.commented" ? "comment" : event.eventType === "workitem.updated" ? "other" : "state_change";
+		return [{
+			...base,
+			kind,
+			thread,
+			repo: thread?.repo,
+			actor: toActor(instance, resource.revisedBy),
+			summary: event.message?.text ?? event.eventType
+		}];
+	}
+	if (event.eventType === "git.push" && repo) {
+		const updates = resource.refUpdates ?? [];
+		const commits = (resource.commits ?? []).map((commit) => ({
+			sha: commit.commitId,
+			message: commit.comment ?? "",
+			author: commit.author?.name,
+			url: commit.url
+		}));
+		const actor = toActor(instance, resource.pushedBy);
+		const zero = /^0+$/;
+		return updates.map((update, index) => ({
+			...base,
+			id: `${event.id}:${index}`,
+			actor,
+			...refEvent(actor?.login ?? "someone", {
+				ref: update.name,
+				before: update.oldObjectId,
+				after: update.newObjectId,
+				created: zero.test(update.oldObjectId ?? ""),
+				deleted: zero.test(update.newObjectId ?? ""),
+				commits
+			})
+		}));
+	}
+	if (event.eventType === "git.repo.renamed" && repo) return [{
+		...base,
+		kind: "repo",
+		action: "renamed",
+		detail: {
+			type: "repo_renamed",
+			from: String(resource.oldName ?? ""),
+			to: repository.name
+		},
+		summary: event.message?.text ?? "Repository renamed"
+	}];
+	return [{
+		...base,
+		kind: "other",
+		summary: event.message?.text ?? event.eventType
+	}];
+}
+const AZURE_WEBHOOK_EVENTS = [
+	{
+		kind: "comment",
+		action: "created"
+	},
+	{
+		kind: "state_change",
+		action: "opened"
+	},
+	{
+		kind: "state_change",
+		action: "closed"
+	},
+	{
+		kind: "state_change",
+		action: "merged"
+	},
+	{
+		kind: "review",
+		action: "submitted"
+	},
+	{ kind: "push" }
+];
+const azureDevOpsWebhooks = ({ options, instance }) => ({
+	events: AZURE_WEBHOOK_EVENTS,
+	verify: async (delivery) => verifyAzureBasicAuth(delivery, options.webhookSecret),
+	translate: (delivery) => translateAzureWebhook(instance, options.organization, delivery)
+});
+//#endregion
+//#region src/azure-devops/index.ts
+/** The REST API version sent with every request; preview endpoints set their own. */
+const AZURE_DEVOPS_API_VERSION = "7.1";
+const POLICY_API_VERSION = "7.1-preview.1";
+const COMMENTS_API_VERSION = "7.1-preview.4";
+const ISSUE_AND_PULL = {
+	issue: true,
+	pull_request: true
+};
+const PER_PAGE = 50;
+/** System work item types that are not issues: test management and code review records. */
+const NOT_ISSUES = [
+	"Test Case",
+	"Test Plan",
+	"Test Suite",
+	"Shared Steps",
+	"Shared Parameter",
+	"Code Review Request",
+	"Code Review Response",
+	"Feedback Request",
+	"Feedback Response"
+];
+const MERGE_STRATEGIES = {
+	merge: "noFastForward",
+	squash: "squash",
+	rebase: "rebase",
+	rebase_merge: "rebaseMerge"
+};
+function versionType(ref) {
+	return /^[0-9a-f]{40}$/i.test(ref) ? "commit" : "branch";
+}
+function setupAzure({ options, instance, origin: context, fetcher, baseUrl }) {
+	const enc = encodeURIComponent;
+	/** Pull request statuses, policy evaluations and WIQL queries redirect a request without credentials to sign in. */
+	const anonymous = options.auth?.type === "anonymous";
+	const STATUS_STATES = {
+		pending: "pending",
+		success: "succeeded",
+		failure: "failed",
+		neutral: "notApplicable",
+		unknown: "notSet"
+	};
+	function scope(repo) {
+		const slash = repo.owner.indexOf("/");
+		if (slash < 0) return {
+			org: options.organization,
+			project: repo.owner
+		};
+		return {
+			org: repo.owner.slice(0, slash),
+			project: repo.owner.slice(slash + 1)
+		};
+	}
+	const projectPath = (repo) => {
+		const { org, project } = scope(repo);
+		return `/${enc(org)}/${enc(project)}/_apis`;
+	};
+	const repoPath = (repo) => `${projectPath(repo)}/git/repositories/${enc(repo.externalId ?? repo.name)}`;
+	const pullPath = (ref) => `${repoPath(ref.repo)}/pullRequests/${ref.number}`;
+	const workItemPath = (ref) => `${projectPath(ref.repo)}/wit/workitems/${ref.number}`;
+	const issueRef = (repo, id) => {
+		const { org, project } = scope(repo);
+		return {
+			forge: FORGE,
+			instance,
+			repo: projectRef(instance, org, project),
+			kind: "issue",
+			number: id
+		};
+	};
+	const categories = /* @__PURE__ */ new Map();
+	function stateCategories(repo, type) {
+		const key = `${repo.owner}:${type}`;
+		let found = categories.get(key);
+		if (!found) {
+			found = fetcher.json(`${projectPath(repo)}/wit/workitemtypes/${enc(type)}/states`).then(({ data }) => new Map(data.value.map((state) => [state.name, state.category])));
+			found.catch(() => categories.delete(key));
+			categories.set(key, found);
+		}
+		return found;
+	}
+	async function workItemThread(ref, raw) {
+		const type = raw.fields["System.WorkItemType"];
+		return toWorkItemThread(ref, raw, type ? (await stateCategories(ref.repo, type)).get(raw.fields["System.State"]) : void 0);
+	}
+	const myId = memo(() => fetcher.json(`/${enc(options.organization)}/_apis/connectionData`, { query: { "api-version": "7.1-preview.1" } }).then(({ data }) => data.authenticatedUser.id));
+	async function pullChecks(ref, pull, signal) {
+		const [statuses, evaluations] = await Promise.all([fetcher.json(`${pullPath(ref)}/statuses`, { signal }), fetcher.json(`${projectPath(ref.repo)}/policy/evaluations`, {
+			query: {
+				"artifactId": `vstfs:///CodeReview/CodeReviewId/${pull.repository.project.id}/${pull.pullRequestId}`,
+				"api-version": POLICY_API_VERSION
+			},
+			signal
+		})]);
+		return [...statuses.data.value.map((raw) => toStatusCheck(ref.repo, raw)), ...evaluations.data.value.map((raw) => toPolicyCheck(ref.repo, raw))];
+	}
+	/** Azure DevOps has reviewer votes, not reviews: one synthesised review per voter. */
+	function toVoteReview(ref, reviewer) {
+		const state = reviewer.vote >= 5 ? "approved" : reviewer.vote <= -5 ? "changes_requested" : "pending";
+		return syntheticReview(ref, `vote:${reviewer.id}`, state, {
+			author: toActor(instance, reviewer),
+			stateRaw: `vote:${reviewer.vote}`,
+			raw: reviewer
+		});
+	}
+	async function createReview(thread, input, options) {
+		const ref = requireThread(thread, context);
+		if (ref.kind !== "pull_request") throw new UnsupportedOperationError("Only pull requests can be reviewed", context);
+		if (input.event !== "approve" && input.event !== "request_changes") throw new UnsupportedOperationError("Azure DevOps records votes, not review bodies", context);
+		if (input.body || input.comments?.length) throw new UnsupportedOperationError("Azure DevOps votes carry no body or inline comments; post them as comment threads", context);
+		const id = await myId();
+		const vote = input.event === "approve" ? 10 : -10;
+		const { data } = await fetcher.json(`${pullPath(ref)}/reviewers/${enc(id)}`, {
+			method: "PUT",
+			json: { vote },
+			signal: options?.signal
+		});
+		return toVoteReview(ref, {
+			...data,
+			id: data.id ?? id,
+			vote: data.vote ?? vote
+		});
+	}
+	async function setThreadStatus(thread, id, status, options) {
+		const ref = requireThread(thread, context);
+		await fetcher.raw(`${pullPath(ref)}/threads/${enc(id)}`, {
+			method: "PATCH",
+			json: { status },
+			signal: options?.signal
+		});
+	}
+	async function get(thread, options) {
+		const ref = requireIssueOrPull(thread, context, "read");
+		if (ref.kind === "issue") return workItemThread(issueRef(ref.repo, ref.number), (await fetcher.json(workItemPath(ref), {
+			query: { $expand: "links" },
+			signal: options?.signal
+		})).data);
+		const { data } = await fetcher.json(pullPath(ref), { signal: options?.signal });
+		const result = toPullThread({
+			...ref,
+			repo: toRepoRef(instance, scope(ref.repo).org, data.repository)
+		}, data);
+		if (anonymous) return result;
+		try {
+			result.checks = summariseChecks((await pullChecks(ref, data, options?.signal)).map((check) => check.state));
+		} catch (error) {
+			if (!(error instanceof ForgeError)) throw error;
+			result.warnings = [...result.warnings ?? [], toWarning("checks_unreadable", error, ref.number)];
+		}
+		return result;
+	}
+	async function pullPage(repo, status, query, cursor) {
+		const skip = Number(cursor?.token ?? 0);
+		const top = Math.min(query.perPage ?? PER_PAGE, 1e3);
+		const { data } = await fetcher.json(`${repoPath(repo)}/pullrequests`, {
+			query: {
+				"searchCriteria.status": status,
+				"searchCriteria.minTime": query.createdAfter?.toISOString(),
+				"searchCriteria.queryTimeRangeType": query.createdAfter ? "created" : void 0,
+				"$top": top,
+				"$skip": skip
+			},
+			signal: query.signal
+		});
+		const { org } = scope(repo);
+		return {
+			items: data.value.filter((raw) => !query.author || raw.createdBy?.uniqueName === query.author || raw.createdBy?.id === query.author).filter((raw) => !query.labels?.length || query.labels.every((label) => raw.labels?.some((item) => item.name === label))).map((raw) => toPullThread({
+				forge: FORGE,
+				instance,
+				repo: toRepoRef(instance, org, raw.repository),
+				kind: "pull_request",
+				number: String(raw.pullRequestId)
+			}, raw)),
+			cursor: data.value.length === top ? { token: String(skip + top) } : void 0
+		};
+	}
+	function wiql(query) {
+		const literal = (value) => `'${value.replaceAll("'", "''")}'`;
+		const clauses = [
+			"[System.TeamProject] = @project",
+			`[System.WorkItemType] NOT IN (${NOT_ISSUES.map(literal).join(", ")})`,
+			...(query.labels ?? []).map((label) => `[System.Tags] CONTAINS ${literal(label)}`),
+			...query.author ? [`[System.CreatedBy] = ${literal(query.author)}`] : [],
+			...query.assignee ? [`[System.AssignedTo] = ${literal(query.assignee)}`] : [],
+			...query.since ? [`[System.ChangedDate] >= ${literal(query.since.toISOString())}`] : [],
+			...query.createdAfter ? [`[System.CreatedDate] >= ${literal(query.createdAfter.toISOString())}`] : [],
+			...query.text ? [`[System.Title] CONTAINS ${literal(query.text)}`] : []
+		];
+		const order = query.sort === "updated" ? "[System.ChangedDate]" : "[System.CreatedDate]";
+		return `SELECT [System.Id] FROM WorkItems WHERE ${clauses.join(" AND ")} ORDER BY ${order} ${(query.direction ?? "desc").toUpperCase()}`;
+	}
+	/** WIQL returns every matching id; each page reads its slice of them. */
+	async function workItemPage(repo, query, cursor) {
+		const offset = Number(cursor?.token ?? 0);
+		const size = Math.min(query.perPage ?? PER_PAGE, 200);
+		const { data } = await fetcher.json(`${projectPath(repo)}/wit/wiql`, {
+			method: "POST",
+			json: { query: wiql(query) },
+			signal: query.signal
+		});
+		const ids = data.workItems.slice(offset, offset + size).map((item) => item.id);
+		if (!ids.length) return { items: [] };
+		const { data: batch } = await fetcher.json(`${projectPath(repo)}/wit/workitemsbatch`, {
+			method: "POST",
+			json: {
+				ids,
+				$expand: "Links"
+			},
+			signal: query.signal
+		});
+		const state = query.state ?? "open";
+		return {
+			items: (await Promise.all(batch.value.map((raw) => workItemThread(issueRef(repo, String(raw.id)), raw)))).filter((thread) => state === "all" || thread.state === state),
+			cursor: offset + size < data.workItems.length ? { token: String(offset + size) } : void 0
+		};
+	}
+	async function listPage(repo, query = {}) {
+		if (query.kind === "discussion") return {
+			items: [],
+			warnings: [{
+				code: "kind_unsupported",
+				message: "Azure DevOps has no discussions"
+			}]
+		};
+		const warnings = [];
+		if (!query.cursor && query.kind !== "issue") {
+			if (query.sort && query.sort !== "created") warnings.push({
+				code: "sort_unsupported",
+				message: "Azure DevOps lists pull requests newest first only"
+			});
+			if (query.assignee || query.since) warnings.push({
+				code: "filter_unsupported",
+				message: "Azure DevOps pull requests have no assignees or update-time filter; those filters were ignored"
+			});
+		}
+		const state = query.state ?? "open";
+		const pullStates = state === "open" ? ["active"] : state === "merged" ? ["completed"] : state === "closed" ? ["completed", "abandoned"] : ["all"];
+		const phases = [];
+		if (query.kind !== "pull_request") {
+			if (!anonymous) phases.push((cursor) => workItemPage(repo, query, cursor));
+			else if (!query.cursor) warnings.push({
+				code: "kind_unsupported",
+				message: "Azure DevOps lists work items only to signed-in users; this listing has pull requests only"
+			});
+		}
+		if (query.kind !== "issue") phases.push(...pullStates.map((status) => (cursor) => pullPage(repo, status, query, cursor)));
+		const page = await phased(phases, query.cursor);
+		return warnings.length ? {
+			...page,
+			warnings: [...warnings, ...page.warnings ?? []]
+		} : page;
+	}
+	async function threads(ref, options) {
+		return (await fetcher.json(`${pullPath(ref)}/threads`, { signal: options?.signal })).data.value.filter((thread) => !thread.isDeleted);
+	}
+	/** Pull request threads come unpaged, so comments are one complete page; work item comments page by continuation token. */
+	async function commentsPage(thread, listOptions = {}) {
+		const ref = requireIssueOrPull(thread, context, "list comments on");
+		if (ref.kind === "pull_request") return { items: (await threads(ref, listOptions)).filter(isConversationThread).flatMap((item) => item.comments.filter((comment) => !comment.isDeleted && comment.commentType !== "system").map((comment) => toPullComment(ref, item, comment))) };
+		const issue = issueRef(ref.repo, ref.number);
+		const { data } = await fetcher.json(`${workItemPath(ref)}/comments`, {
+			query: {
+				"api-version": COMMENTS_API_VERSION,
+				"$top": listOptions.perPage ?? PER_PAGE,
+				"continuationToken": listOptions.cursor?.token
+			},
+			signal: listOptions.signal
+		});
+		return {
+			items: data.comments.filter((comment) => !comment.isDeleted).map((raw) => toWorkItemComment(issue, raw)),
+			cursor: data.continuationToken ? { token: data.continuationToken } : void 0
+		};
+	}
+	async function eventsPage(thread, listOptions = {}) {
+		const ref = requireIssueOrPull(thread, context, "list events on");
+		if (ref.kind === "pull_request") return { items: (await threads(ref, listOptions)).flatMap((item) => toThreadEvents(ref, item)).sort((a, b) => a.occurredAt.getTime() - b.occurredAt.getTime()) };
+		const issue = issueRef(ref.repo, ref.number);
+		const [{ data: updates }, { data: comments }] = await Promise.all([fetcher.json(`${workItemPath(ref)}/updates`, { signal: listOptions.signal }), fetcher.json(`${workItemPath(ref)}/comments`, {
+			query: { "api-version": COMMENTS_API_VERSION },
+			signal: listOptions.signal
+		})]);
+		return { items: toWorkItemEvents(issue, updates.value, comments.comments.filter((comment) => !comment.isDeleted)) };
+	}
+	async function patchWorkItem(ref, fields, signal) {
+		const { data } = await fetcher.json(workItemPath(ref), {
+			method: "PATCH",
+			headers: { "content-type": "application/json-patch+json" },
+			body: JSON.stringify(Object.entries(fields).map(([name, value]) => ({
+				op: "add",
+				path: `/fields/${name}`,
+				value
+			}))),
+			signal
+		});
+		return data;
+	}
+	async function stateIn(ref, wanted, options) {
+		const { data } = await fetcher.json(workItemPath(ref), { signal: options?.signal });
+		const type = data.fields["System.WorkItemType"];
+		for (const [name, category] of await stateCategories(ref.repo, type)) if (wanted.includes(category)) return name;
+		throw new UnsupportedOperationError(`The ${type} work item type has no ${wanted.join(" or ")} state`, context);
+	}
+	async function setState(thread, state, options) {
+		const ref = requireIssueOrPull(thread, context, state === "open" ? "reopen" : "close");
+		if (ref.kind === "pull_request") {
+			await fetcher.raw(pullPath(ref), {
+				method: "PATCH",
+				json: { status: state === "open" ? "active" : "abandoned" },
+				signal: options?.signal
+			});
+			return;
+		}
+		await patchWorkItem(ref, { "System.State": await stateIn(ref, state === "open" ? ["Proposed", "InProgress"] : ["Completed"], options) }, options?.signal);
+	}
+	function splitCommentId(ref) {
+		const [thread = "", comment = ""] = ref.id.split("/");
+		return {
+			thread,
+			comment
+		};
+	}
+	/** WIQL runs against one project, and reaches work items only: Azure DevOps has no pull request search. */
+	async function searchThreadsPage(query) {
+		if (!query.repo) throw new UnsupportedOperationError("Azure DevOps work item search is scoped to a project; pass `repo`", context);
+		if (query.kind === "pull_request") return {
+			items: [],
+			warnings: [{
+				code: "kind_unsupported",
+				message: "Azure DevOps has no pull request search"
+			}]
+		};
+		const warnings = query.involves && !query.cursor ? [{
+			code: "filter_unsupported",
+			message: "Azure DevOps WIQL has no involves filter; it was ignored"
+		}] : [];
+		const page = await workItemPage(query.repo, {
+			text: query.text,
+			state: query.state ?? "all",
+			labels: query.labels,
+			author: query.author,
+			assignee: query.assignee,
+			since: query.since,
+			sort: query.sort === "created" ? "created" : "updated",
+			direction: query.direction,
+			perPage: query.perPage,
+			signal: query.signal
+		}, query.cursor);
+		return warnings.length ? {
+			...page,
+			warnings: [...warnings, ...page.warnings ?? []]
+		} : page;
+	}
+	return {
+		traits: {
+			eventKinds: "native",
+			authKinds: [
+				"token",
+				"basic",
+				"anonymous"
+			]
+		},
+		search: { threadsPage: verb(!anonymous, searchThreadsPage) },
+		repos: {
+			get: verb(true, async (ref, options) => {
+				const { data } = await fetcher.json(repoPath(ref), { signal: options?.signal });
+				return toRepo(instance, scope(ref).org, data);
+			}),
+			listPage: verb(true, async (listOptions) => {
+				const { data } = await fetcher.json(`/${enc(options.organization)}/_apis/git/repositories`, { signal: listOptions?.signal });
+				return { items: data.value.map((raw) => toRepo(instance, options.organization, raw)) };
+			})
+		},
+		contents: {
+			file: verb(true, async (repo, path, fileOptions = {}) => {
+				const query = {
+					path,
+					download: "true",
+					$format: "octetStream",
+					...fileOptions.ref ? {
+						"versionDescriptor.version": fileOptions.ref,
+						"versionDescriptor.versionType": versionType(fileOptions.ref)
+					} : {}
+				};
+				const response = await fetcher.raw(`${repoPath(repo)}/items`, {
+					query,
+					signal: fileOptions.signal
+				});
+				return toFileContent(new Uint8Array(await response.arrayBuffer()), { path: path.replace(/^\//, "") }, fileOptions, context);
+			}),
+			treePage: verb(true, async (repo, treeOptions = {}) => {
+				const { data } = await fetcher.json(`${repoPath(repo)}/items`, {
+					query: {
+						scopePath: treeOptions.path ? `/${treeOptions.path.replace(/^\//, "")}` : "/",
+						recursionLevel: treeOptions.recursive ? "full" : "oneLevel",
+						...treeOptions.ref ? {
+							"versionDescriptor.version": treeOptions.ref,
+							"versionDescriptor.versionType": versionType(treeOptions.ref)
+						} : {}
+					},
+					signal: treeOptions.signal
+				});
+				return { items: data.value.filter((item) => item.path !== "/").map(toTreeEntry) };
+			}),
+			branchesPage: verb(true, async (repo, listOptions = {}) => {
+				const { data } = await fetcher.json(`${repoPath(repo)}/refs`, {
+					query: { filter: "heads/" },
+					signal: listOptions.signal
+				});
+				return { items: data.value.map(toBranch) };
+			}),
+			tagsPage: verb(true, async (repo, listOptions = {}) => {
+				const { data } = await fetcher.json(`${repoPath(repo)}/refs`, {
+					query: {
+						filter: "tags/",
+						peelTags: "true"
+					},
+					signal: listOptions.signal
+				});
+				return { items: data.value.map(toTag) };
+			}),
+			resolveRef: verb(true, async (repo, ref, options) => {
+				const { data } = await fetcher.json(`${repoPath(repo)}/commits`, {
+					query: {
+						"searchCriteria.itemVersion.version": ref,
+						"$top": 1
+					},
+					signal: options?.signal
+				});
+				const sha = data.value[0]?.commitId;
+				if (!sha) throw new NotFoundError(`Azure DevOps has no commit for ${ref}`, 404, "", context);
+				return sha;
+			}),
+			commitsPage: verb(true, async (repo, query = {}) => {
+				const { data } = await fetcher.json(`${repoPath(repo)}/commits`, {
+					query: {
+						"searchCriteria.itemVersion.version": query.ref,
+						"searchCriteria.itemPath": query.path,
+						"searchCriteria.author": query.author,
+						"searchCriteria.fromDate": query.since?.toISOString(),
+						"searchCriteria.toDate": query.until?.toISOString(),
+						"$top": query.perPage
+					},
+					signal: query.signal
+				});
+				return { items: data.value.map((raw) => toCommit(repo, raw)) };
+			}),
+			commit: verb(true, async (repo, sha, options) => {
+				const { data } = await fetcher.json(`${repoPath(repo)}/commits/${sha}`, {
+					query: { changeCount: 100 },
+					signal: options?.signal
+				});
+				return toCommit(repo, data, (data.changes ?? []).filter((change) => !change.item?.isFolder).map(toChangedFile));
+			}),
+			compare: verb(true, async (repo, base, head, options) => {
+				const { data } = await fetcher.json(`${repoPath(repo)}/diffs/commits`, {
+					query: {
+						baseVersion: base,
+						baseVersionType: versionType(base),
+						targetVersion: head,
+						targetVersionType: versionType(head),
+						$top: 1e3
+					},
+					signal: options?.signal
+				});
+				return {
+					base,
+					head,
+					aheadBy: data.aheadCount,
+					behindBy: data.behindCount,
+					mergeBaseSha: data.commonCommit,
+					commits: [],
+					files: (data.changes ?? []).filter((change) => !change.item?.isFolder).map(toChangedFile),
+					raw: data
+				};
+			})
+		},
+		checks: {
+			list: verb(true, async (repo, sha, options) => ({ items: (await fetcher.json(`${repoPath(repo)}/commits/${sha}/statuses`, { signal: options?.signal })).data.value.map((raw) => toStatusCheck(repo, raw)) })),
+			report: verb(true, async (repo, sha, input, options) => toStatusCheck(repo, (await fetcher.json(`${repoPath(repo)}/commits/${sha}/statuses`, {
+				method: "POST",
+				json: {
+					state: STATUS_STATES[input.state],
+					description: input.description,
+					targetUrl: input.url,
+					context: {
+						name: input.name,
+						genre: input.externalId ?? "forges"
+					}
+				},
+				signal: options?.signal
+			})).data))
+		},
+		threads: {
+			get: perKind({
+				issue: anonymous ? "unverified" : true,
+				pull_request: true
+			}, get),
+			getMany: verb(true, (refs, options) => getManyConcurrently(refs, get, options)),
+			listPage: perKind({
+				issue: !anonymous,
+				pull_request: true
+			}, listPage),
+			eventsPage: verb(true, eventsPage),
+			commitsPage: verb(true, async (thread, listOptions = {}) => {
+				const ref = requireThread(thread, context);
+				if (ref.kind !== "pull_request") throw new UnsupportedOperationError("Only pull requests can be read for commits", context);
+				const { data } = await fetcher.json(`${pullPath(ref)}/commits`, {
+					query: { $top: listOptions.perPage },
+					signal: listOptions.signal
+				});
+				return { items: data.value.map((raw) => toCommit(ref.repo, raw)) };
+			}),
+			commentsPage: perKind({
+				issue: anonymous ? "unverified" : "experimental",
+				pull_request: true
+			}, commentsPage),
+			comment: perKind({
+				issue: "experimental",
+				pull_request: true
+			}, async (thread, body, options) => {
+				const ref = requireIssueOrPull(thread, context, "comment on");
+				if (ref.kind === "issue") {
+					const { data } = await fetcher.json(`${workItemPath(ref)}/comments`, {
+						method: "POST",
+						json: { text: body },
+						query: { "api-version": COMMENTS_API_VERSION },
+						signal: options?.signal
+					});
+					return toWorkItemComment(issueRef(ref.repo, ref.number), data);
+				}
+				const { data } = await fetcher.json(`${pullPath(ref)}/threads`, {
+					method: "POST",
+					json: {
+						comments: [{
+							parentCommentId: 0,
+							content: body,
+							commentType: "text"
+						}],
+						status: "active"
+					},
+					signal: options?.signal
+				});
+				return toPullComment(ref, data, data.comments[0]);
+			}),
+			editComment: perKind({
+				issue: "experimental",
+				pull_request: true
+			}, async (ref, body, options) => {
+				const thread = requireIssueOrPull(ref.thread, context, "edit comments on");
+				if (thread.kind === "issue") {
+					const { data } = await fetcher.json(`${workItemPath(thread)}/comments/${ref.id}`, {
+						method: "PATCH",
+						json: { text: body },
+						query: { "api-version": COMMENTS_API_VERSION },
+						signal: options?.signal
+					});
+					return toWorkItemComment(issueRef(thread.repo, thread.number), data);
+				}
+				const ids = splitCommentId(ref);
+				const { data } = await fetcher.json(`${pullPath(thread)}/threads/${ids.thread}/comments/${ids.comment}`, {
+					method: "PATCH",
+					json: { content: body },
+					signal: options?.signal
+				});
+				return toPullComment(thread, {
+					id: Number(ids.thread),
+					comments: []
+				}, data);
+			}),
+			deleteComment: perKind({
+				issue: "experimental",
+				pull_request: true
+			}, async (ref, options) => {
+				const thread = requireIssueOrPull(ref.thread, context, "delete comments on");
+				if (thread.kind === "issue") {
+					await fetcher.raw(`${workItemPath(thread)}/comments/${ref.id}`, {
+						method: "DELETE",
+						query: { "api-version": COMMENTS_API_VERSION },
+						signal: options?.signal
+					});
+					return;
+				}
+				const ids = splitCommentId(ref);
+				await fetcher.raw(`${pullPath(thread)}/threads/${ids.thread}/comments/${ids.comment}`, {
+					method: "DELETE",
+					signal: options?.signal
+				});
+			}),
+			create: perKind({
+				issue: true,
+				pull_request: true
+			}, async (repo, input, writeOptions) => {
+				if (input.kind === "issue") {
+					if ((input.assignees?.length ?? 0) > 1) throw new UnsupportedOperationError("Azure DevOps work items take a single assignee", context);
+					const fields = { "System.Title": input.title };
+					if (input.body) fields["System.Description"] = input.body;
+					if (input.labels?.length) fields["System.Tags"] = input.labels.join("; ");
+					if (input.assignees?.[0]) fields["System.AssignedTo"] = typeof input.assignees[0] === "string" ? input.assignees[0] : input.assignees[0].login;
+					const { data } = await fetcher.json(`${projectPath(repo)}/wit/workitems/$${enc(options.issueType ?? "Issue")}`, {
+						method: "POST",
+						headers: { "content-type": "application/json-patch+json" },
+						body: JSON.stringify(Object.entries(fields).map(([name, value]) => ({
+							op: "add",
+							path: `/fields/${name}`,
+							value
+						}))),
+						signal: writeOptions?.signal
+					});
+					return workItemThread(issueRef(repo, String(data.id)), data);
+				}
+				if (!input.head || !input.base) throw new UnsupportedOperationError("Creating a pull request needs head and base branches", context);
+				const { data } = await fetcher.json(`${repoPath(repo)}/pullrequests`, {
+					method: "POST",
+					json: {
+						sourceRefName: `refs/heads/${input.head}`,
+						targetRefName: `refs/heads/${input.base}`,
+						title: input.title,
+						description: input.body,
+						isDraft: input.draft ?? false,
+						labels: input.labels?.map((name) => ({ name })),
+						reviewers: input.assignees?.map((reviewer) => ({ id: typeof reviewer === "string" ? reviewer : reviewer.id }))
+					},
+					signal: writeOptions?.signal
+				});
+				return toPullThread({
+					forge: FORGE,
+					instance,
+					repo,
+					kind: "pull_request",
+					number: String(data.pullRequestId)
+				}, data);
+			}),
+			update: perKind({
+				issue: true,
+				pull_request: true
+			}, async (thread, input, options) => {
+				const ref = requireIssueOrPull(thread, context, "update");
+				if (ref.kind === "issue") {
+					const fields = {};
+					if (input.title !== void 0) fields["System.Title"] = input.title;
+					if (input.body !== void 0) fields["System.Description"] = input.body;
+					return workItemThread(issueRef(ref.repo, ref.number), await patchWorkItem(ref, fields, options?.signal));
+				}
+				const { data } = await fetcher.json(pullPath(ref), {
+					method: "PATCH",
+					json: {
+						title: input.title,
+						description: input.body
+					},
+					signal: options?.signal
+				});
+				return toPullThread(ref, data);
+			}),
+			close: perKind(ISSUE_AND_PULL, (ref, options) => setState(ref, "closed", options)),
+			reopen: perKind({
+				issue: true,
+				pull_request: true
+			}, (ref, options) => setState(ref, "open", options)),
+			setLabels: perKind({
+				issue: true,
+				pull_request: true
+			}, async (thread, labels, options) => {
+				const ref = requireIssueOrPull(thread, context, "label");
+				if (ref.kind === "issue") {
+					await patchWorkItem(ref, { "System.Tags": labels.join("; ") }, options?.signal);
+					return;
+				}
+				const { data } = await fetcher.json(`${pullPath(ref)}/labels`, { signal: options?.signal });
+				const current = data.value.map((label) => label.name);
+				for (const label of data.value.filter((item) => !labels.includes(item.name))) await fetcher.raw(`${pullPath(ref)}/labels/${enc(label.id)}`, {
+					method: "DELETE",
+					signal: options?.signal
+				});
+				for (const name of labels.filter((item) => !current.includes(item))) await fetcher.raw(`${pullPath(ref)}/labels`, {
+					method: "POST",
+					json: { name },
+					signal: options?.signal
+				});
+			}),
+			setAssignees: perKind({ issue: true }, async (thread, assignees, options) => {
+				if (assignees.length > 1) throw new UnsupportedOperationError("Azure DevOps work items take a single assignee", context);
+				const assignee = assignees[0];
+				await patchWorkItem(requireIssueOrPull(thread, context, "assign"), { "System.AssignedTo": assignee === void 0 ? "" : typeof assignee === "string" ? assignee : assignee.login }, options?.signal);
+			}),
+			requestReview: perKind({ pull_request: true }, async (thread, reviewers, options) => {
+				const ref = requireThread(thread, context);
+				for (const reviewer of reviewers) {
+					const id = typeof reviewer === "string" ? reviewer : reviewer.id;
+					await fetcher.raw(`${pullPath(ref)}/reviewers/${enc(id)}`, {
+						method: "PUT",
+						json: { vote: 0 },
+						signal: options?.signal
+					});
+				}
+			}),
+			merge: verb(true, async (thread, mergeOptions = {}, hooks = {}) => {
+				const ref = requireThread(thread, context);
+				if (ref.kind !== "pull_request") throw new UnsupportedOperationError("Only pull requests can be completed", context);
+				if (!mergeOptions.method) throw new MergeMethodRequiredError(Object.keys(MERGE_STRATEGIES), context);
+				if (mergeOptions.method === "fast_forward_only") throw new UnsupportedOperationError("Azure DevOps does not support fast-forward-only completion", context);
+				const message = mergeCommitMessage(mergeOptions);
+				const completionOptions = {
+					mergeStrategy: MERGE_STRATEGIES[mergeOptions.method],
+					...message ? { mergeCommitMessage: message } : {}
+				};
+				const id = await myId();
+				await hooks.beforeMerge?.();
+				if (mergeOptions.whenChecksPass) {
+					await fetcher.raw(pullPath(ref), {
+						method: "PATCH",
+						json: {
+							autoCompleteSetBy: { id },
+							completionOptions
+						},
+						mapError: toMergeError,
+						signal: mergeOptions.signal
+					});
+					return;
+				}
+				const sha = mergeOptions.sha ?? (await fetcher.json(pullPath(ref), { signal: mergeOptions.signal })).data.lastMergeSourceCommit?.commitId;
+				await fetcher.raw(pullPath(ref), {
+					method: "PATCH",
+					json: {
+						status: "completed",
+						lastMergeSourceCommit: { commitId: sha },
+						completionOptions
+					},
+					mapError: toMergeError,
+					signal: mergeOptions.signal
+				});
+			}),
+			checks: perKind({ pull_request: !anonymous && "experimental" }, async (thread, options) => {
+				const ref = requireThread(thread, context);
+				return { items: await pullChecks(ref, (await fetcher.json(pullPath(ref), { signal: options?.signal })).data, options?.signal) };
+			}),
+			reviewsPage: verb("emulated", async (thread, listOptions) => {
+				const ref = requireThread(thread, context);
+				const { data } = await fetcher.json(pullPath(ref), { signal: listOptions?.signal });
+				return { items: (data.reviewers ?? []).filter((reviewer) => reviewer.vote !== 0).map((reviewer) => toVoteReview(ref, reviewer)) };
+			}),
+			createReview: verb("emulated", createReview),
+			reviewThreads: verb(true, {
+				resolveReviewThread: (thread, id, options) => setThreadStatus(thread, id, "closed", options),
+				unresolveReviewThread: (thread, id, options) => setThreadStatus(thread, id, "active", options)
+			})
+		},
+		web: azureWeb(baseUrl),
+		webhooks: {},
+		scopes: (verb) => verb.startsWith("webhooks.") ? {
+			token: ["vso.work_full"],
+			note: "Service hook subscriptions need project administrator rights"
+		} : { token: ["vso.code", "vso.work"] }
+	};
+}
+const AZURE_DEVOPS = {
+	forge: FORGE,
+	baseUrl: "https://dev.azure.com",
+	anonymous: true,
+	headers: { accept: "application/json" },
+	query: { "api-version": "7.1" },
+	authHeaders: ({ options: { auth } }) => {
+		if (!auth || auth.type === "anonymous") return;
+		return async () => ({ authorization: `Basic ${btoa(auth.type === "token" ? `:${await resolveToken(auth)}` : `${auth.username}:${auth.password}`)}` });
+	},
+	setup: setupAzure
+};
+/** Creates an Azure DevOps provider for one organization on dev.azure.com, or a collection on Azure DevOps Server. */
+const azureDevOps = /* @__PURE__ */ defineForgeProvider({
+	...AZURE_DEVOPS,
+	webhooks: azureDevOpsWebhooks
+});
+/** `azureDevOps()` without webhook ingestion, for bundles that never receive a delivery. */
+const azureDevOpsLite = /* @__PURE__ */ defineForgeProvider(AZURE_DEVOPS);
+//#endregion
+export { azureDevOps as n, azureDevOpsLite as r, AZURE_DEVOPS_API_VERSION as t };