forges 0.0.0 → 0.1.0

package/dist/bitbucket-CpcfJlYi.mjs

@@ -0,0 +1,1171 @@
+import { A as toPage, B as isNamespaceRef, D as syntheticReview, E as summariseChecks, Mt as WebhookVerificationError, Nt as soleMergeMethod, O as toDate, Pt as toMergeError, S as phased, St as MergeConflictError, T as resolveToken, _t as ForgeError, b as mergeCommitMessage, f as getManyConcurrently, ft as toFileContent, h as hostOf, j as toWarning, jt as UnsupportedOperationError, k as toFileStatus, l as createListing, n as perKind, r as verb, t as defineForgeProvider, w as requireThread } from "./define-D3yEXtKK.mjs";
+import { l as toBase64, n as headerValue, t as bodyText } from "./crypto-CQNEyYHD.mjs";
+import { a as verifyHmacSignature, i as refEvent, r as nativeEventsFor, t as eventKindsOf } from "./webhooks-rn9-8lxT.mjs";
+//#region src/bitbucket/webhook-events.ts
+/** Native Bitbucket event names per normalised kind, for hook subscriptions. */
+const BITBUCKET_NATIVE_EVENTS = {
+	comment: [
+		"pullrequest:comment_created",
+		"pullrequest:comment_updated",
+		"pullrequest:comment_deleted"
+	],
+	review: [
+		"pullrequest:approved",
+		"pullrequest:unapproved",
+		"pullrequest:changes_request_created"
+	],
+	state_change: [
+		"pullrequest:created",
+		"pullrequest:updated",
+		"pullrequest:fulfilled",
+		"pullrequest:rejected"
+	],
+	push: ["repo:push"],
+	ref: ["repo:push"],
+	repo: ["repo:updated", "repo:transfer"]
+};
+/** Normalised kinds and actions Bitbucket deliveries translate into. */
+const BITBUCKET_WEBHOOK_EVENTS = [
+	{
+		kind: "comment",
+		action: "created"
+	},
+	{
+		kind: "comment",
+		action: "edited"
+	},
+	{
+		kind: "comment",
+		action: "deleted"
+	},
+	{
+		kind: "review",
+		action: "submitted"
+	},
+	{
+		kind: "state_change",
+		action: "opened"
+	},
+	{
+		kind: "state_change",
+		action: "closed"
+	},
+	{
+		kind: "state_change",
+		action: "merged"
+	},
+	{ kind: "push" },
+	{
+		kind: "ref",
+		action: "created"
+	},
+	{
+		kind: "ref",
+		action: "deleted"
+	},
+	{
+		kind: "repo",
+		action: "renamed"
+	},
+	{
+		kind: "repo",
+		action: "transferred"
+	}
+];
+//#endregion
+//#region src/bitbucket/normalise.ts
+const FORGE = "bitbucket";
+function toActor(instance, user) {
+	if (!user) return;
+	const login = user.nickname ?? user.username ?? user.display_name ?? user.uuid ?? "unknown";
+	return {
+		forge: FORGE,
+		instance,
+		login,
+		id: user.uuid ?? user.account_id ?? login,
+		name: user.display_name,
+		avatarUrl: user.links?.avatar?.href,
+		url: user.links?.html?.href,
+		typeRaw: user.type,
+		isBotHint: user.type === "app_user"
+	};
+}
+function toRepoRef(instance, repo) {
+	const [workspace = "", slug = ""] = repo.full_name.split("/");
+	return {
+		forge: FORGE,
+		instance,
+		owner: repo.workspace?.slug ?? workspace,
+		name: repo.slug ?? slug,
+		externalId: repo.uuid
+	};
+}
+function toRepo(instance, raw) {
+	const clone = (name) => raw.links?.clone?.find((link) => link.name === name)?.href;
+	return {
+		ref: toRepoRef(instance, raw),
+		description: raw.description || void 0,
+		defaultBranch: raw.mainbranch?.name,
+		visibility: raw.is_private ? "private" : "public",
+		visibilityRaw: raw.is_private === void 0 ? void 0 : raw.is_private ? "private" : "public",
+		isFork: Boolean(raw.parent),
+		isArchived: false,
+		parent: raw.parent ? toRepoRef(instance, raw.parent) : void 0,
+		topics: [],
+		url: raw.links?.html?.href,
+		cloneUrls: clone("https") || clone("ssh") ? {
+			https: clone("https"),
+			ssh: clone("ssh")
+		} : void 0,
+		createdAt: toDate(raw.created_on),
+		updatedAt: toDate(raw.updated_on),
+		owner: toActor(instance, raw.owner),
+		language: raw.language || void 0,
+		homepage: raw.website || void 0,
+		features: raw.has_issues === void 0 ? void 0 : {
+			issues: raw.has_issues,
+			pullRequests: true,
+			discussions: false,
+			wiki: raw.has_wiki ?? false,
+			projects: false,
+			releases: false
+		},
+		raw
+	};
+}
+function toPullState(state) {
+	switch (state) {
+		case "OPEN": return "open";
+		case "MERGED": return "merged";
+		case "DECLINED":
+		case "SUPERSEDED": return "closed";
+		default: return "unknown";
+	}
+}
+const STRATEGIES = {
+	merge_commit: "merge",
+	squash: "squash",
+	fast_forward: "fast_forward_only",
+	rebase_merge: "rebase_merge",
+	rebase_fast_forward: "rebase"
+};
+function toMergeMethod(strategy) {
+	return STRATEGIES[strategy];
+}
+function toStrategy(method) {
+	return Object.entries(STRATEGIES).find(([, value]) => value === method)[0];
+}
+function toReviewers(instance, raw) {
+	const participants = new Map((raw.participants ?? []).map((participant) => [participant.user?.uuid, participant]));
+	return (raw.reviewers ?? []).flatMap((user) => {
+		const actor = toActor(instance, user);
+		if (!actor) return [];
+		const participant = participants.get(user.uuid);
+		const stateRaw = participant?.state ?? (participant?.approved ? "approved" : void 0);
+		return [{
+			actor,
+			state: stateRaw === "approved" ? "approved" : stateRaw === "changes_requested" ? "changes_requested" : "pending",
+			stateRaw: stateRaw ?? void 0
+		}];
+	});
+}
+function toPullThread(ref, raw) {
+	const repo = raw.destination?.repository;
+	const threadRepo = repo ? {
+		...ref.repo,
+		externalId: repo.uuid ?? ref.repo.externalId
+	} : ref.repo;
+	return {
+		ref: {
+			...ref,
+			repo: threadRepo
+		},
+		kind: "pull_request",
+		title: raw.title,
+		body: raw.description ?? raw.summary?.raw,
+		state: toPullState(raw.state),
+		stateRaw: raw.state,
+		isDraft: raw.draft ?? false,
+		assignees: [],
+		reviewers: toReviewers(ref.instance, raw),
+		lastActivityAt: toDate(raw.updated_on),
+		branches: raw.source?.branch && raw.destination?.branch ? {
+			head: {
+				ref: raw.source.branch.name,
+				sha: raw.source.commit?.hash,
+				repo: raw.source.repository ? toRepoRef(ref.instance, raw.source.repository) : void 0
+			},
+			base: {
+				ref: raw.destination.branch.name,
+				sha: raw.destination.commit?.hash
+			},
+			mergeCommitSha: raw.merge_commit?.hash
+		} : void 0,
+		author: toActor(ref.instance, raw.author),
+		url: raw.links?.html?.href,
+		createdAt: toDate(raw.created_on),
+		updatedAt: toDate(raw.updated_on),
+		closedAt: raw.state === "OPEN" ? void 0 : toDate(raw.updated_on),
+		labels: [],
+		commentCount: raw.comment_count,
+		raw
+	};
+}
+function toCommitThread(ref, raw) {
+	return {
+		ref,
+		kind: "commit",
+		title: raw.message?.split("\n")[0] ?? raw.hash,
+		body: raw.message,
+		state: "unknown",
+		isDraft: false,
+		assignees: [],
+		reviewers: [],
+		lastActivityAt: toDate(raw.date),
+		author: toActor(ref.instance, raw.author?.user),
+		url: raw.links?.html?.href,
+		createdAt: toDate(raw.date),
+		labels: [],
+		raw
+	};
+}
+function event(thread, id, kind, kindRaw, actor, summary, at, payload) {
+	return {
+		forge: FORGE,
+		instance: thread.instance,
+		id,
+		kind,
+		kindRaw,
+		summary: `${actor?.login ?? "someone"} ${summary}`,
+		occurredAt: toDate(at) ?? /* @__PURE__ */ new Date(0),
+		actor,
+		repo: thread.repo,
+		thread,
+		source: "poll",
+		payload
+	};
+}
+function toCommentEvent(thread, comment) {
+	const inline = Boolean(comment.inline);
+	return event(thread, `comment:${comment.id}`, inline ? "review_comment" : "comment", inline ? "comment.inline" : "comment", toActor(thread.instance, comment.user), inline ? "commented on a line" : "commented", comment.created_on, comment);
+}
+/** Pull request activity entries are a union keyed by their single property. */
+function toActivityEvent(thread, entry, index) {
+	if (entry.comment) return toCommentEvent(thread, entry.comment);
+	if (entry.approval) return event(thread, `approval:${entry.approval.user?.uuid ?? index}:${entry.approval.date}`, "review", "approval", toActor(thread.instance, entry.approval.user), "approved", entry.approval.date, entry);
+	if (entry.changes_requested) return event(thread, `changes_requested:${entry.changes_requested.user?.uuid ?? index}:${entry.changes_requested.date}`, "review", "changes_requested", toActor(thread.instance, entry.changes_requested.user), "requested changes", entry.changes_requested.date, entry);
+	const update = entry.update;
+	const terminal = update?.state && update.state !== "OPEN";
+	return event(thread, `update:${update?.date ?? index}`, terminal ? "state_change" : "other", terminal ? `update.${update.state}` : "update", toActor(thread.instance, update?.author), terminal ? update.state.toLowerCase() : "updated the pull request", update?.date, entry);
+}
+function toComment(thread, raw) {
+	return {
+		ref: {
+			forge: FORGE,
+			instance: thread.instance,
+			thread,
+			id: String(raw.id)
+		},
+		body: raw.content?.raw ?? "",
+		author: toActor(thread.instance, raw.user),
+		createdAt: toDate(raw.created_on),
+		updatedAt: toDate(raw.updated_on),
+		url: raw.links?.html?.href,
+		raw
+	};
+}
+/** Bitbucket renders Markdown without HTML, so collapsible blocks become a bold heading and their content. */
+function normaliseMarkdown(body) {
+	return body.replace(/<summary>([\s\S]*?)<\/summary>/gi, (_, summary) => `**${summary.trim()}**\n`).replace(/<\/?details[^>]*>/gi, "");
+}
+/** `STOPPED` builds were cancelled, which counts as a failure. */
+function statusState(state) {
+	return state === "SUCCESSFUL" ? "success" : state === "FAILED" || state === "STOPPED" ? "failure" : state === "INPROGRESS" ? "pending" : "unknown";
+}
+function toStatusCheck(repo, raw) {
+	const state = statusState(raw.state);
+	return {
+		ref: {
+			forge: FORGE,
+			instance: repo.instance,
+			repo,
+			id: raw.uuid ?? raw.key,
+			type: "status"
+		},
+		name: raw.name ?? raw.key,
+		state,
+		stateRaw: raw.state,
+		url: raw.url,
+		startedAt: toDate(raw.created_on),
+		completedAt: state === "pending" ? void 0 : toDate(raw.updated_on),
+		raw
+	};
+}
+function toCommit(repo, raw, files) {
+	const authored = raw.author?.raw;
+	const match = authored ? /^(?<name>[^<]*)<(?<email>[^>]*)>$/.exec(authored) : void 0;
+	return {
+		ref: {
+			forge: FORGE,
+			instance: repo.instance,
+			repo,
+			sha: raw.hash
+		},
+		sha: raw.hash,
+		message: raw.message ?? raw.summary?.raw ?? "",
+		author: {
+			actor: toActor(repo.instance, raw.author?.user),
+			name: match?.groups?.name?.trim() || authored,
+			email: match?.groups?.email,
+			date: toDate(raw.date)
+		},
+		parents: raw.parents?.flatMap((parent) => parent.hash ? [parent.hash] : []) ?? [],
+		url: raw.links?.html?.href,
+		...files ? { files } : {},
+		raw
+	};
+}
+/** Bitbucket reports changes as a diffstat, with the old and new paths rather than a rename flag. */
+function toChangedFile(raw) {
+	return {
+		path: raw.new?.path ?? raw.old?.path ?? "",
+		previousPath: raw.status === "renamed" ? raw.old?.path : void 0,
+		status: toFileStatus(raw.status),
+		statusRaw: raw.status,
+		additions: raw.lines_added,
+		deletions: raw.lines_removed
+	};
+}
+function toBranch(raw, defaultBranch) {
+	return {
+		name: raw.name,
+		sha: raw.target?.hash ?? "",
+		isDefault: defaultBranch === void 0 ? void 0 : raw.name === defaultBranch,
+		url: raw.links?.html?.href,
+		raw
+	};
+}
+function toTag(raw) {
+	return {
+		name: raw.name,
+		sha: raw.target?.hash ?? "",
+		url: raw.links?.html?.href,
+		raw
+	};
+}
+function toTreeEntry(raw) {
+	return {
+		path: raw.path,
+		type: raw.type === "commit_directory" ? "directory" : raw.attributes?.includes("link") ? "symlink" : "file",
+		size: raw.size,
+		sha: raw.commit?.hash
+	};
+}
+function toWebhook(target, raw) {
+	const nativeEvents = raw.events ?? [];
+	return {
+		ref: {
+			forge: FORGE,
+			instance: target.instance,
+			target,
+			id: raw.uuid
+		},
+		url: raw.url,
+		events: eventKindsOf(BITBUCKET_NATIVE_EVENTS, nativeEvents),
+		nativeEvents,
+		active: raw.active ?? true,
+		createdAt: toDate(raw.created_at),
+		raw
+	};
+}
+//#endregion
+//#region src/bitbucket/web.ts
+const SECTIONS = {
+	issue: "issues",
+	pull_request: "pull-requests",
+	commit: "commits"
+};
+const KINDS = new Map(Object.entries(SECTIONS).map(([kind, section]) => [section, kind]));
+const repoPath = (repo) => `/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.name)}`;
+function bitbucketWeb(origin) {
+	return {
+		origin,
+		repo: repoPath,
+		thread: (ref) => SECTIONS[ref.kind] && `${repoPath(ref.repo)}/${SECTIONS[ref.kind]}/${encodeURIComponent(ref.number)}`,
+		comment: (ref) => ref.thread.kind === "commit" || !SECTIONS[ref.thread.kind] ? void 0 : `${repoPath(ref.thread.repo)}/${SECTIONS[ref.thread.kind]}/${encodeURIComponent(ref.thread.number)}#comment-${ref.id}`,
+		file: (repo, path, at, line) => `${repoPath(repo)}/src/${encodeURIComponent(at)}/${path.split("/").map(encodeURIComponent).join("/")}${line ? `#lines-${line}` : ""}`,
+		compare: (repo, base, head) => `${repoPath(repo)}/branches/compare/${encodeURIComponent(head)}%0D${encodeURIComponent(base)}`,
+		parse: (segments, url, from) => {
+			const [owner, name, section, id] = segments;
+			if (!owner || !name) return;
+			const repo = {
+				...from,
+				owner,
+				name: name.replace(/\.git$/, "")
+			};
+			const kind = section ? KINDS.get(section) : void 0;
+			if (!kind || !id) return { repo };
+			const thread = {
+				...from,
+				repo,
+				kind,
+				number: id
+			};
+			const comment = url.hash.startsWith("#comment-") ? url.hash.slice(9) : void 0;
+			return {
+				repo,
+				thread,
+				...comment ? { comment: {
+					...from,
+					thread,
+					id: comment
+				} } : {}
+			};
+		},
+		reference: (ref, same) => {
+			if (!same) return;
+			return ref.kind === "issue" ? `#${ref.number}` : ref.kind === "pull_request" ? `pull request #${ref.number}` : ref.kind === "commit" ? ref.number.slice(0, 12) : void 0;
+		}
+	};
+}
+//#endregion
+//#region src/bitbucket/webhooks.ts
+const SIGNATURE_HEADER = "x-hub-signature";
+const EVENT_HEADER = "x-event-key";
+/** Bitbucket signs with `X-Hub-Signature: sha256=<hex>` only when the webhook has a secret. */
+function verifyBitbucketSignature(delivery, secret) {
+	return verifyHmacSignature(delivery, secret, {
+		header: SIGNATURE_HEADER,
+		prefix: "sha256="
+	});
+}
+const EVENT_KINDS = {
+	"pullrequest:created": "state_change",
+	"pullrequest:fulfilled": "state_change",
+	"pullrequest:rejected": "state_change",
+	"pullrequest:approved": "review",
+	"pullrequest:unapproved": "review",
+	"pullrequest:changes_request_created": "review",
+	"pullrequest:changes_request_removed": "review",
+	"pullrequest:comment_created": "comment"
+};
+function translateBitbucketWebhook(instance, delivery) {
+	const event = headerValue(delivery.headers, EVENT_HEADER);
+	if (!event) throw new WebhookVerificationError(`Missing ${EVENT_HEADER} header`, {
+		forge: FORGE,
+		instance
+	});
+	const deliveryId = headerValue(delivery.headers, "x-request-uuid") ?? crypto.randomUUID();
+	const payload = JSON.parse(bodyText(delivery.body));
+	const repo = payload.repository ? toRepoRef(instance, payload.repository) : void 0;
+	const actor = toActor(instance, payload.actor);
+	const who = actor?.login ?? "someone";
+	const thread = repo && payload.pullrequest ? {
+		forge: FORGE,
+		instance,
+		repo,
+		kind: "pull_request",
+		number: String(payload.pullrequest.id)
+	} : void 0;
+	if (event === "repo:push" && payload.push) return payload.push.changes.map((change, index) => {
+		const ref = change.new ?? change.old;
+		const refType = ref?.type === "tag" ? "tag" : "branch";
+		const name = ref?.name ?? "";
+		return {
+			forge: FORGE,
+			instance,
+			id: `${deliveryId}:${index}`,
+			kindRaw: event,
+			actor,
+			repo,
+			source: "webhook",
+			payload: {
+				...payload,
+				push: { changes: [change] }
+			},
+			...refEvent(who, {
+				ref: name,
+				refType,
+				before: change.old?.target?.hash,
+				after: change.new?.target?.hash,
+				deleted: change.closed,
+				created: change.created && !change.commits?.length,
+				forced: change.forced,
+				commits: (change.commits ?? []).map((commit) => ({
+					sha: commit.hash,
+					message: commit.message,
+					author: commit.author?.raw,
+					url: commit.links?.html?.href
+				}))
+			}),
+			occurredAt: toDate(change.commits?.[0]?.date) ?? /* @__PURE__ */ new Date()
+		};
+	});
+	if (event === "repo:updated" && payload.changes?.name) return [{
+		forge: FORGE,
+		instance,
+		id: deliveryId,
+		kind: "repo",
+		action: "renamed",
+		kindRaw: event,
+		summary: `${who} renamed the repository`,
+		occurredAt: /* @__PURE__ */ new Date(),
+		actor,
+		repo,
+		detail: {
+			type: "repo_renamed",
+			from: payload.changes.name.old,
+			to: payload.changes.name.new
+		},
+		source: "webhook",
+		payload
+	}];
+	if (event === "repo:transfer") return [{
+		forge: FORGE,
+		instance,
+		id: deliveryId,
+		kind: "repo",
+		action: "transferred",
+		kindRaw: event,
+		summary: `${who} transferred the repository`,
+		occurredAt: /* @__PURE__ */ new Date(),
+		actor,
+		repo,
+		detail: {
+			type: "repo_transferred",
+			fromOwner: payload.previous_workspace?.slug,
+			toOwner: repo?.owner
+		},
+		source: "webhook",
+		payload
+	}];
+	const kind = EVENT_KINDS[event] ?? "other";
+	return [{
+		forge: FORGE,
+		instance,
+		id: deliveryId,
+		kind,
+		kindRaw: event,
+		summary: `${who} ${event.split(":")[1]?.replaceAll("_", " ") ?? event}`,
+		occurredAt: toDate(payload.comment?.created_on ?? payload.approval?.date ?? payload.pullrequest?.updated_on) ?? /* @__PURE__ */ new Date(),
+		actor,
+		repo,
+		thread,
+		source: "webhook",
+		payload
+	}];
+}
+const bitbucketWebhooks = ({ options, instance }) => ({
+	events: BITBUCKET_WEBHOOK_EVENTS,
+	verify: (delivery) => verifyBitbucketSignature(delivery, options.webhookSecret),
+	translate: (delivery) => translateBitbucketWebhook(instance, delivery)
+});
+//#endregion
+//#region src/bitbucket/index.ts
+const PULL_STATES = {
+	open: ["OPEN"],
+	merged: ["MERGED"],
+	closed: [
+		"MERGED",
+		"DECLINED",
+		"SUPERSEDED"
+	],
+	all: [
+		"OPEN",
+		"MERGED",
+		"DECLINED",
+		"SUPERSEDED"
+	]
+};
+/** A BBQL string literal. */
+function bbql(value) {
+	return `"${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+}
+function accountRef(actor) {
+	return { uuid: typeof actor === "string" ? actor : actor.id };
+}
+function page(body) {
+	const { values, next } = body;
+	return {
+		items: values,
+		next
+	};
+}
+/** Creates a Bitbucket Cloud provider. Bitbucket Data Center has a different API and is not supported. */
+const BITBUCKET = {
+	forge: FORGE,
+	baseUrl: "https://api.bitbucket.org/2.0",
+	anonymous: true,
+	instance: (host) => host === "api.bitbucket.org" ? "bitbucket.org" : host,
+	headers: { accept: "application/json" },
+	authHeaders({ options: { auth } }) {
+		if (!auth || auth.type === "anonymous") return;
+		if (auth.type === "token") return async () => ({ authorization: `Bearer ${await resolveToken(auth)}` });
+		const authorization = `Basic ${toBase64(new TextEncoder().encode(`${auth.username}:${auth.password}`))}`;
+		return () => ({ authorization });
+	},
+	setup({ options, instance, origin: context, fetcher, baseUrl }) {
+		const list = createListing(fetcher, "pagelen", 50);
+		const webOrigin = hostOf(baseUrl) === "api.bitbucket.org" ? "https://bitbucket.org" : baseUrl.replace(/\/2\.0$/, "");
+		/** Repository search covers the signed-in account's workspaces. */
+		const anonymous = options.auth?.type === "anonymous";
+		function repoPath(ref) {
+			return `/repositories/${encodeURIComponent(ref.repo.owner)}/${encodeURIComponent(ref.repo.name)}`;
+		}
+		function threadPath(ref) {
+			switch (ref.kind) {
+				case "pull_request": return `${repoPath(ref)}/pullrequests/${ref.number}`;
+				case "commit": return `${repoPath(ref)}/commit/${ref.number}`;
+				default: throw new UnsupportedOperationError(`Bitbucket has no ${ref.kind} threads`, context);
+			}
+		}
+		function all(path, listOptions = {}) {
+			return fetcher.items(path, {
+				query: { pagelen: listOptions.perPage ?? 50 },
+				signal: listOptions.signal,
+				select: page
+			});
+		}
+		async function resolveMergeMethod(ref, pull, signal) {
+			const branch = pull?.destination?.branch?.name ?? (await fetcher.json(threadPath(ref), { signal })).data.destination?.branch?.name;
+			const { data } = await fetcher.json(`${repoPath(ref)}/refs/branches/${encodeURIComponent(branch ?? "")}`, { signal });
+			return soleMergeMethod(Object.fromEntries((data.merge_strategies ?? []).map(toMergeMethod).filter((method) => method !== void 0).map((method) => [method, true])), context);
+		}
+		async function merge(thread, mergeOptions = {}, hooks = {}) {
+			const ref = requireThread(thread, context);
+			if (ref.kind !== "pull_request") throw new UnsupportedOperationError("Only pull requests can be merged", context);
+			if (mergeOptions.whenChecksPass) throw new UnsupportedOperationError("Bitbucket Cloud cannot queue a merge until checks pass through the API", context);
+			let pull;
+			if (mergeOptions.sha) {
+				pull = (await fetcher.json(threadPath(ref), { signal: mergeOptions.signal })).data;
+				const head = pull.source?.commit?.hash ?? "";
+				if (!head || !(mergeOptions.sha.startsWith(head) || head.startsWith(mergeOptions.sha))) throw new MergeConflictError(`Pull request head is ${head || "unknown"}, not ${mergeOptions.sha}`, 409, "", context);
+			}
+			const method = mergeOptions.method ?? await resolveMergeMethod(ref, pull, mergeOptions.signal);
+			await hooks.beforeMerge?.();
+			await fetcher.raw(`${threadPath(ref)}/merge`, {
+				method: "POST",
+				json: {
+					merge_strategy: toStrategy(method),
+					message: mergeCommitMessage(mergeOptions)
+				},
+				mapError: toMergeError,
+				signal: mergeOptions.signal
+			});
+		}
+		const STATUS_STATES = {
+			pending: "INPROGRESS",
+			success: "SUCCESSFUL",
+			failure: "FAILED",
+			neutral: "STOPPED",
+			unknown: "INPROGRESS"
+		};
+		function repoPathOf(repo) {
+			return `/repositories/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.name)}`;
+		}
+		function requirePull(thread, action) {
+			const ref = requireThread(thread, context);
+			if (ref.kind !== "pull_request") throw new UnsupportedOperationError(`Only pull requests can be ${action}`, context);
+			return ref;
+		}
+		/** Bitbucket's source endpoints need an explicit commit or branch, so the main branch stands in. */
+		async function mainBranch(repo, options) {
+			const { data } = await fetcher.json(repoPathOf(repo), { signal: options?.signal });
+			return data.mainbranch?.name ?? "HEAD";
+		}
+		async function get(thread, options) {
+			const ref = requireThread(thread, context);
+			switch (ref.kind) {
+				case "pull_request": {
+					const result = toPullThread(ref, (await fetcher.json(threadPath(ref), { signal: options?.signal })).data);
+					try {
+						result.checks = summariseChecks((await pullChecks(ref, 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;
+				}
+				case "commit": return toCommitThread(ref, (await fetcher.json(threadPath(ref), { signal: options?.signal })).data);
+				default: throw new UnsupportedOperationError(`Bitbucket has no ${ref.kind} threads`, context);
+			}
+		}
+		async function listPage(repo, query = {}) {
+			if (query.kind && query.kind !== "pull_request") return {
+				items: [],
+				warnings: [{
+					code: "kind_unsupported",
+					message: `Bitbucket Cloud has no ${query.kind === "issue" ? "issues" : "discussions"}`
+				}]
+			};
+			const warnings = [];
+			if (!query.cursor) {
+				if (query.labels?.length) warnings.push({
+					code: "filter_unsupported",
+					message: "Bitbucket has no labels; the labels filter was ignored"
+				});
+				if (query.sort === "comments") warnings.push({
+					code: "sort_unsupported",
+					message: "Bitbucket cannot sort by comment count; sorted by creation time"
+				});
+				if (query.assignee) warnings.push({
+					code: "filter_unsupported",
+					message: "Bitbucket pull requests have no assignees; the assignee filter was ignored"
+				});
+			}
+			const field = query.sort === "updated" ? "updated_on" : "created_on";
+			const clauses = [];
+			if (query.since) clauses.push(`updated_on >= ${query.since.toISOString()}`);
+			if (query.createdAfter) clauses.push(`created_on >= ${query.createdAfter.toISOString()}`);
+			if (query.author) clauses.push(`author.nickname = ${bbql(query.author)}`);
+			const params = new URLSearchParams({
+				sort: `${(query.direction ?? "desc") === "desc" ? "-" : ""}${field}`,
+				pagelen: String(query.perPage ?? 50)
+			});
+			for (const value of PULL_STATES[query.state ?? "open"]) params.append("state", value);
+			if (clauses.length) params.set("q", clauses.join(" AND "));
+			const result = await fetcher.page(`${repoPathOf(repo)}/pullrequests?${params}`, {
+				signal: query.signal,
+				cursor: query.cursor,
+				select: page
+			});
+			return toPage(result, (raw) => toPullThread({
+				forge: FORGE,
+				instance,
+				repo,
+				kind: "pull_request",
+				number: String(raw.id)
+			}, raw), warnings.length ? warnings : void 0);
+		}
+		/** Repository hooks, or workspace hooks for a namespace ref. */
+		function hooksPath(target) {
+			return isNamespaceRef(target) ? `/workspaces/${encodeURIComponent(target.owner)}/hooks` : `${repoPathOf(target)}/hooks`;
+		}
+		/** Bitbucket replaces a hook whole, so a change is merged into the hook as it is. */
+		async function putHook(ref, changes, options) {
+			const path = `${hooksPath(ref.target)}/${ref.id}`;
+			const { data: current } = await fetcher.json(path, { signal: options?.signal });
+			const { data } = await fetcher.json(path, {
+				method: "PUT",
+				json: {
+					url: current.url,
+					description: current.description,
+					active: current.active,
+					events: current.events,
+					...changes
+				},
+				signal: options?.signal
+			});
+			return toWebhook(ref.target, data);
+		}
+		/**
+		* Bitbucket indexes issues and pull requests per repository, so search is
+		* the same `q=` filter language scoped to one repository.
+		*/
+		async function searchThreadsPage(query) {
+			if (!query.repo) throw new UnsupportedOperationError("Bitbucket has no cross-repository issue or pull request search; pass `repo`", context);
+			const warnings = [];
+			if (!query.cursor) {
+				if (query.labels?.length) warnings.push({
+					code: "filter_unsupported",
+					message: "Bitbucket has no labels; the label filter was ignored"
+				});
+				if (query.involves) warnings.push({
+					code: "filter_unsupported",
+					message: "Bitbucket has no involves filter; it was ignored"
+				});
+				if (query.sort === "comments") warnings.push({
+					code: "sort_unsupported",
+					message: "Bitbucket cannot sort by comment count; sorted by update time"
+				});
+			}
+			const page = await listPage(query.repo, {
+				kind: query.kind,
+				state: query.state ?? "all",
+				author: query.author,
+				assignee: query.assignee,
+				since: query.since,
+				sort: query.sort === "created" ? "created" : "updated",
+				direction: query.direction,
+				perPage: query.perPage,
+				cursor: query.cursor,
+				signal: query.signal
+			});
+			const text = query.text?.toLowerCase();
+			const items = text ? page.items.filter((thread) => thread.title.toLowerCase().includes(text) || (thread.body ?? "").toLowerCase().includes(text)) : page.items;
+			const all = [...warnings, ...page.warnings ?? []];
+			return {
+				...page,
+				items,
+				...all.length ? { warnings: all } : {}
+			};
+		}
+		async function searchReposPage(query) {
+			const clauses = [...query.text ? [`name ~ ${bbql(query.text)}`] : [], ...query.language ? [`language = ${bbql(query.language)}`] : []];
+			const field = query.sort === "created" ? "created_on" : "updated_on";
+			const extras = {
+				query: {
+					q: clauses.length ? clauses.join(" AND ") : void 0,
+					sort: `${(query.direction ?? "desc") === "desc" ? "-" : ""}${field}`
+				},
+				warnings: query.sort === "stars" ? [{
+					code: "sort_unsupported",
+					message: "Bitbucket has no stars; sorted by update time"
+				}] : void 0
+			};
+			return query.owner ? list(`/repositories/${encodeURIComponent(query.owner)}`, query, (raw) => toRepo(instance, raw), {
+				...extras,
+				select: page
+			}) : memberRepos(query, extras);
+		}
+		/** One phase per workspace the account belongs to; Bitbucket lists repositories by workspace only. */
+		async function memberRepos(listOptions, extras = {}) {
+			const workspaces = await Array.fromAsync(fetcher.items("/user/workspaces", {
+				query: { pagelen: 100 },
+				select: page,
+				signal: listOptions.signal
+			}));
+			if (!workspaces.length) return { items: [] };
+			return phased(workspaces.map(({ workspace }) => (cursor) => list(`/repositories/${encodeURIComponent(workspace.slug)}`, {
+				...listOptions,
+				cursor
+			}, (raw) => toRepo(instance, raw), {
+				...extras,
+				query: {
+					...extras.query,
+					role: "member"
+				},
+				select: page
+			})), listOptions.cursor);
+		}
+		/** Bitbucket has participants, not reviews: one synthesised review per participant who has voted. */
+		function toParticipantReviews(ref, pull) {
+			return (pull.participants ?? []).flatMap((participant) => {
+				const stateRaw = participant.state ?? (participant.approved ? "approved" : void 0);
+				if (!stateRaw) return [];
+				const actor = toActor(instance, participant.user);
+				const state = stateRaw === "approved" ? "approved" : stateRaw === "changes_requested" ? "changes_requested" : "unknown";
+				return [syntheticReview(ref, `participant:${participant.user?.uuid ?? actor?.login ?? ""}`, state, {
+					author: actor,
+					stateRaw,
+					raw: participant
+				})];
+			});
+		}
+		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("Bitbucket records approve and request-changes votes, not review bodies", context);
+			if (input.body || input.comments?.length) throw new UnsupportedOperationError("Bitbucket votes carry no body or inline comments; post them as comments", context);
+			const { data } = await fetcher.json(`${threadPath(ref)}/${input.event === "approve" ? "approve" : "request-changes"}`, {
+				method: "POST",
+				signal: options?.signal
+			});
+			return toParticipantReviews(ref, { participants: [data] })[0] ?? {
+				ref: {
+					forge: "bitbucket",
+					instance,
+					thread: ref,
+					id: "participant:"
+				},
+				state: "unknown",
+				comments: false,
+				raw: data
+			};
+		}
+		function pullChecks(ref, signal) {
+			return Array.fromAsync(all(`${threadPath(ref)}/statuses`, { signal }), (status) => toStatusCheck(ref.repo, status));
+		}
+		function commentsPath(ref) {
+			return `${threadPath(ref)}/comments`;
+		}
+		function commentPath(ref) {
+			return `${commentsPath(requireThread(ref.thread, context))}/${ref.id}`;
+		}
+		return {
+			traits: {
+				eventKinds: "native",
+				authKinds: [
+					"token",
+					"basic",
+					"anonymous"
+				]
+			},
+			normaliseMarkdown,
+			users: { me: verb(true, async (options) => {
+				const { data } = await fetcher.json("/user", { signal: options?.signal });
+				return {
+					...toActor(instance, data),
+					raw: data
+				};
+			}) },
+			web: bitbucketWeb(webOrigin),
+			webhooks: {
+				listPage: verb(true, (target, listOptions = {}) => list(hooksPath(target), listOptions, (raw) => toWebhook(target, raw), { select: page })),
+				create: verb(true, async (target, input, options) => toWebhook(target, (await fetcher.json(hooksPath(target), {
+					method: "POST",
+					json: {
+						url: input.url,
+						description: "forges",
+						active: input.active ?? true,
+						events: nativeEventsFor(BITBUCKET_NATIVE_EVENTS, input.events, input.nativeEvents),
+						...input.secret ? { secret: input.secret } : {}
+					},
+					signal: options?.signal
+				})).data)),
+				update: verb(true, async (ref, update, options) => putHook(ref, {
+					...update.url ? { url: update.url } : {},
+					...update.active === void 0 ? {} : { active: update.active },
+					...update.events || update.nativeEvents ? { events: nativeEventsFor(BITBUCKET_NATIVE_EVENTS, update.events, update.nativeEvents) } : {},
+					...update.secret ? { secret: update.secret } : {}
+				}, options)),
+				delete: verb(true, async (ref, options) => {
+					await fetcher.raw(`${hooksPath(ref.target)}/${ref.id}`, {
+						method: "DELETE",
+						signal: options?.signal
+					});
+				}),
+				rotateSecret: verb(true, async (ref, secret, options) => putHook(ref, { secret }, options))
+			},
+			scopes: bitbucketScopesFor,
+			repos: {
+				get: verb(true, async (ref, options) => {
+					return toRepo(instance, (await fetcher.json(repoPathOf(ref), { signal: options?.signal })).data);
+				}),
+				listPage: verb(true, (listOptions = {}) => memberRepos(listOptions))
+			},
+			search: {
+				threadsPage: verb(true, searchThreadsPage),
+				reposPage: verb(!anonymous, searchReposPage)
+			},
+			contents: {
+				file: verb(true, async (repo, path, fileOptions = {}) => {
+					const ref = fileOptions.ref ?? await mainBranch(repo, fileOptions);
+					const target = `${repoPathOf(repo)}/src/${encodeURIComponent(ref)}/${path.split("/").map(encodeURIComponent).join("/")}`;
+					const [meta, raw] = await Promise.all([fetcher.json(target, {
+						query: { format: "meta" },
+						signal: fileOptions.signal
+					}), fetcher.raw(target, { signal: fileOptions.signal })]);
+					const file = {
+						path: meta.data.path,
+						sha: meta.data.commit?.hash,
+						size: meta.data.size,
+						url: meta.data.links?.html?.href
+					};
+					return toFileContent(new Uint8Array(await raw.arrayBuffer()), file, fileOptions, context);
+				}),
+				treePage: verb(true, async (repo, treeOptions = {}) => {
+					const ref = treeOptions.ref ?? await mainBranch(repo, treeOptions);
+					const path = treeOptions.path?.replace(/^\/|\/$/g, "") ?? "";
+					return list(`${repoPathOf(repo)}/src/${encodeURIComponent(ref)}/${path.split("/").map(encodeURIComponent).join("/")}`, treeOptions, toTreeEntry, {
+						query: { max_depth: treeOptions.recursive ? 100 : void 0 },
+						select: page
+					});
+				}),
+				branchesPage: verb(true, (repo, listOptions = {}) => list(`${repoPathOf(repo)}/refs/branches`, listOptions, (raw) => toBranch(raw), { select: page })),
+				tagsPage: verb(true, (repo, listOptions = {}) => list(`${repoPathOf(repo)}/refs/tags`, listOptions, toTag, { select: page })),
+				resolveRef: verb(true, async (repo, ref, options) => (await fetcher.json(`${repoPathOf(repo)}/commit/${encodeURIComponent(ref)}`, { signal: options?.signal })).data.hash),
+				commitsPage: verb(true, (repo, query = {}) => list(`${repoPathOf(repo)}/commits${query.ref ? `/${encodeURIComponent(query.ref)}` : ""}`, query, (raw) => toCommit(repo, raw), {
+					query: { path: query.path },
+					select: page
+				})),
+				commit: verb(true, async (repo, sha, options) => {
+					const [commit, files] = await Promise.all([fetcher.json(`${repoPathOf(repo)}/commit/${sha}`, { signal: options?.signal }), Array.fromAsync(all(`${repoPathOf(repo)}/diffstat/${sha}`, { signal: options?.signal }), toChangedFile)]);
+					return toCommit(repo, commit.data, files);
+				}),
+				compare: verb(true, async (repo, base, head, options) => {
+					const [files, commits] = await Promise.all([Array.fromAsync(all(`${repoPathOf(repo)}/diffstat/${encodeURIComponent(head)}..${encodeURIComponent(base)}`, { signal: options?.signal }), toChangedFile), Array.fromAsync(fetcher.items(`${repoPathOf(repo)}/commits`, {
+						query: {
+							include: head,
+							exclude: base,
+							pagelen: 50
+						},
+						select: page,
+						signal: options?.signal
+					}), (raw) => toCommit(repo, raw))]);
+					return {
+						base,
+						head,
+						aheadBy: commits.length,
+						commits,
+						files,
+						raw: {
+							files,
+							commits
+						}
+					};
+				})
+			},
+			checks: {
+				list: verb(true, async (repo, sha, options) => ({ items: await Array.fromAsync(all(`${repoPathOf(repo)}/commit/${sha}/statuses`, { signal: options?.signal }), (raw) => toStatusCheck(repo, raw)) })),
+				report: verb(true, async (repo, sha, input, options) => toStatusCheck(repo, (await fetcher.json(`${repoPathOf(repo)}/commit/${sha}/statuses/build`, {
+					method: "POST",
+					json: {
+						key: input.externalId ?? input.name,
+						name: input.name,
+						state: STATUS_STATES[input.state],
+						description: input.description,
+						url: input.url ?? `${webOrigin}/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.name)}/commits/${sha}`
+					},
+					signal: options?.signal
+				})).data))
+			},
+			threads: {
+				filesPage: verb(true, (thread, listOptions = {}) => list(`${threadPath(requirePull(thread, "read for changed files"))}/diffstat`, listOptions, toChangedFile, { select: page })),
+				commitsPage: verb(true, (thread, listOptions = {}) => list(`${threadPath(requirePull(thread, "read for commits"))}/commits`, listOptions, (raw) => toCommit(thread.repo, raw), { select: page })),
+				checks: perKind({ pull_request: true }, async (thread, options) => ({ items: await pullChecks(requireThread(thread, context), options?.signal) })),
+				reviewsPage: verb("emulated", async (thread, listOptions) => {
+					const ref = requireThread(thread, context);
+					if (ref.kind !== "pull_request") throw new UnsupportedOperationError("Only pull requests have participants", context);
+					return { items: toParticipantReviews(ref, (await fetcher.json(threadPath(ref), { signal: listOptions?.signal })).data) };
+				}),
+				createReview: verb("emulated", createReview),
+				get: perKind({
+					pull_request: true,
+					commit: true
+				}, get),
+				getMany: verb(true, (refs, options) => getManyConcurrently(refs, get, options)),
+				listPage: perKind({ pull_request: true }, listPage),
+				eventsPage: verb(true, async (thread, listOptions = {}) => {
+					const ref = requireThread(thread, context);
+					const events = [];
+					if (ref.kind === "pull_request") {
+						let index = 0;
+						for await (const entry of all(`${threadPath(ref)}/activity`, listOptions)) events.push(toActivityEvent(ref, entry, index++));
+					} else for await (const comment of all(commentsPath(ref), listOptions)) events.push(toCommentEvent(ref, comment));
+					return { items: events.sort((a, b) => a.occurredAt.getTime() - b.occurredAt.getTime()) };
+				}),
+				commentsPage: perKind({
+					pull_request: true,
+					commit: true
+				}, async (thread, listOptions = {}) => {
+					const ref = requireThread(thread, context);
+					return list(commentsPath(ref), listOptions, (comment) => toComment(ref, comment), { select: page });
+				}),
+				comment: perKind({
+					pull_request: true,
+					commit: true
+				}, async (thread, body, options) => {
+					const ref = requireThread(thread, context);
+					const { data } = await fetcher.json(commentsPath(ref), {
+						method: "POST",
+						json: { content: { raw: body } },
+						signal: options?.signal
+					});
+					return toComment(ref, data);
+				}),
+				editComment: perKind({
+					pull_request: true,
+					commit: true
+				}, async (ref, body, options) => {
+					const { data } = await fetcher.json(commentPath(ref), {
+						method: "PUT",
+						json: { content: { raw: body } },
+						signal: options?.signal
+					});
+					return toComment(ref.thread, data);
+				}),
+				deleteComment: perKind({
+					pull_request: true,
+					commit: true
+				}, async (ref, options) => {
+					await fetcher.raw(commentPath(ref), {
+						method: "DELETE",
+						signal: options?.signal
+					});
+				}),
+				create: perKind({ pull_request: true }, async (repo, input, options) => {
+					if (input.labels?.length) throw new UnsupportedOperationError("Bitbucket has no labels", context);
+					if (!input.head || !input.base) throw new UnsupportedOperationError("Creating a pull request needs head and base branches", context);
+					if (input.assignees?.length) throw new UnsupportedOperationError("Bitbucket pull requests have no assignees", context);
+					const { data } = await fetcher.json(`${repoPathOf(repo)}/pullrequests`, {
+						method: "POST",
+						json: {
+							title: input.title,
+							description: input.body,
+							source: { branch: { name: input.head } },
+							destination: { branch: { name: input.base } },
+							draft: input.draft
+						},
+						signal: options?.signal
+					});
+					return toPullThread({
+						forge: FORGE,
+						instance,
+						repo,
+						kind: "pull_request",
+						number: String(data.id)
+					}, data);
+				}),
+				update: perKind({ pull_request: true }, async (thread, input, options) => {
+					const ref = requirePull(thread, "updated");
+					const { data } = await fetcher.json(threadPath(ref), {
+						method: "PUT",
+						json: {
+							title: input.title,
+							description: input.body
+						},
+						signal: options?.signal
+					});
+					return toPullThread(ref, data);
+				}),
+				requestReview: perKind({ pull_request: true }, async (thread, reviewers, options) => {
+					const ref = requireThread(thread, context);
+					if (ref.kind !== "pull_request") throw new UnsupportedOperationError("Only pull requests have reviewers", context);
+					const { data } = await fetcher.json(threadPath(ref), { signal: options?.signal });
+					const uuids = /* @__PURE__ */ new Set([...(data.reviewers ?? []).flatMap((user) => user.uuid ?? []), ...reviewers.map((reviewer) => accountRef(reviewer).uuid)]);
+					await fetcher.raw(threadPath(ref), {
+						method: "PUT",
+						json: {
+							title: data.title,
+							reviewers: [...uuids].map((uuid) => ({ uuid }))
+						},
+						signal: options?.signal
+					});
+				}),
+				close: perKind({ pull_request: true }, async (thread, options) => {
+					await fetcher.raw(`${threadPath(requirePull(thread, "declined"))}/decline`, {
+						method: "POST",
+						signal: options?.signal
+					});
+				}),
+				merge: verb(true, merge)
+			}
+		};
+	}
+};
+/** Creates a Bitbucket Cloud provider. */
+const bitbucket = /* @__PURE__ */ defineForgeProvider({
+	...BITBUCKET,
+	webhooks: bitbucketWebhooks
+});
+/** `bitbucket()` without webhook ingestion, for bundles that never receive a delivery. */
+const bitbucketLite = /* @__PURE__ */ defineForgeProvider(BITBUCKET);
+/** Bitbucket Cloud scopes, as an app password or OAuth consumer grants them. */
+function bitbucketScopesFor(verb) {
+	const [group = "", name = ""] = verb.split(".");
+	if (group === "webhooks") return name === "verify" || name === "ingest" ? {} : { token: ["webhook"] };
+	const write = (/* @__PURE__ */ new Set([
+		"comment",
+		"upsertComment",
+		"editComment",
+		"deleteComment",
+		"create",
+		"update",
+		"close",
+		"reopen",
+		"merge",
+		"approveAndMerge",
+		"approve",
+		"createReview",
+		"submitReview",
+		"setAssignees",
+		"requestReview",
+		"report"
+	])).has(name);
+	if (group === "threads") return { token: [write ? "issue:write" : "issue", write ? "pullrequest:write" : "pullrequest"] };
+	if (group === "users" || group === "search") return { token: ["account"] };
+	return { token: [write ? "repository:write" : "repository"] };
+}
+//#endregion
+export { bitbucketLite as n, bitbucketScopesFor as r, bitbucket as t };