forges 0.0.0 → 0.1.0

package/dist/forgejo-BCefbHUN.mjs

@@ -0,0 +1,2005 @@
+import { A as toPage, B as isNamespaceRef, C as requireIssueOrPull, E as summariseChecks, M as versionAtLeast, Mt as WebhookVerificationError, Nt as soleMergeMethod, O as toDate, Pt as toMergeError, T as resolveToken, Y as reactionContent, _t as ForgeError, ct as eventAction, dt as fromBase64, f as getManyConcurrently, ft as toFileContent, h as hostOf, i as githubShapedWeb, j as toWarning, jt as UnsupportedOperationError, k as toFileStatus, l as createListing, lt as reviewState, m as hexColour, n as perKind, p as hasEveryLabel, r as verb, s as actorLogin, t as defineForgeProvider, v as memo, w as requireThread, wt as NotFoundError, x as milestoneId, y as memoBy } from "./define-D3yEXtKK.mjs";
+import { t as bodyText } from "./crypto-CQNEyYHD.mjs";
+import { a as verifyHmacSignature, i as refEvent, n as firstHeader, r as nativeEventsFor, t as eventKindsOf } from "./webhooks-rn9-8lxT.mjs";
+//#region src/forgejo/webhook-events.ts
+const FORGEJO_HEADERS = {
+	signature: ["x-forgejo-signature", "x-gitea-signature"],
+	event: [
+		"x-forgejo-event",
+		"x-gitea-event",
+		"x-github-event"
+	],
+	delivery: ["x-forgejo-delivery", "x-gitea-delivery"]
+};
+const GITEA_HEADERS = {
+	signature: ["x-gitea-signature"],
+	event: ["x-gitea-event", "x-github-event"],
+	delivery: ["x-gitea-delivery"]
+};
+/** Native Forgejo and Gitea event names per normalised kind, for hook subscriptions. */
+const FORGEJO_NATIVE_EVENTS = {
+	comment: ["issue_comment", "pull_request_comment"],
+	review: [
+		"pull_request_review_approved",
+		"pull_request_review_rejected",
+		"pull_request_review_comment"
+	],
+	review_comment: ["pull_request_review_comment"],
+	state_change: [
+		"issues",
+		"pull_request",
+		"pull_request_sync"
+	],
+	label: ["issue_label", "pull_request_label"],
+	assignment: ["issue_assign", "pull_request_assign"],
+	push: ["push"],
+	ref: ["create", "delete"],
+	release: ["release"]
+};
+/** Normalised kinds and actions Forgejo and Gitea deliveries translate into. */
+const FORGEJO_WEBHOOK_EVENTS = [
+	{
+		kind: "comment",
+		action: "created"
+	},
+	{
+		kind: "comment",
+		action: "edited"
+	},
+	{
+		kind: "comment",
+		action: "deleted"
+	},
+	{
+		kind: "review",
+		action: "submitted"
+	},
+	{
+		kind: "review_comment",
+		action: "created"
+	},
+	{
+		kind: "state_change",
+		action: "opened"
+	},
+	{
+		kind: "state_change",
+		action: "closed"
+	},
+	{
+		kind: "state_change",
+		action: "reopened"
+	},
+	{
+		kind: "state_change",
+		action: "merged"
+	},
+	{
+		kind: "label",
+		action: "edited"
+	},
+	{
+		kind: "label",
+		action: "unlabelled"
+	},
+	{
+		kind: "assignment",
+		action: "assigned"
+	},
+	{
+		kind: "assignment",
+		action: "unassigned"
+	},
+	{ kind: "push" },
+	{
+		kind: "ref",
+		action: "created"
+	},
+	{
+		kind: "ref",
+		action: "deleted"
+	},
+	{
+		kind: "release",
+		action: "published"
+	}
+];
+//#endregion
+//#region src/forgejo/normalise.ts
+/** The id of the built-in user that Forgejo and Gitea Actions act as. */
+const ACTIONS_USER_ID = -2;
+/** Normalisers take the origin because they serve both Forgejo and Gitea. */
+function toActor(origin, user) {
+	if (!user) return;
+	return {
+		...origin,
+		login: user.login,
+		id: String(user.id ?? user.login),
+		name: user.full_name || void 0,
+		avatarUrl: user.avatar_url,
+		url: user.html_url,
+		typeRaw: user.is_bot === void 0 ? void 0 : user.is_bot ? "bot" : "user",
+		isBotHint: user.is_bot === true || user.id === ACTIONS_USER_ID || user.login.endsWith("[bot]")
+	};
+}
+function toRepoRef(origin, repo) {
+	const [owner, name] = repo.full_name.split("/");
+	return {
+		...origin,
+		owner: repo.owner?.login ?? owner ?? "",
+		name: repo.name ?? name ?? "",
+		externalId: repo.id === void 0 ? void 0 : String(repo.id)
+	};
+}
+function toRepo(origin, raw) {
+	return {
+		ref: toRepoRef(origin, raw),
+		description: raw.description || void 0,
+		defaultBranch: raw.default_branch,
+		visibility: raw.internal ? "internal" : raw.private ? "private" : "public",
+		visibilityRaw: raw.internal ? "internal" : raw.private ? "private" : "public",
+		isFork: raw.fork ?? false,
+		isArchived: raw.archived ?? false,
+		parent: raw.parent ? toRepoRef(origin, raw.parent) : void 0,
+		topics: raw.topics ?? [],
+		url: raw.html_url,
+		cloneUrls: raw.clone_url || raw.ssh_url ? {
+			https: raw.clone_url,
+			ssh: raw.ssh_url
+		} : void 0,
+		createdAt: toDate(raw.created_at),
+		updatedAt: toDate(raw.updated_at),
+		openIssueCount: raw.open_issues_count,
+		openPullCount: raw.open_pr_counter,
+		owner: toActor(origin, raw.owner),
+		language: raw.language || void 0,
+		homepage: raw.website || void 0,
+		licence: raw.licenses?.length === 1 ? raw.licenses[0] : void 0,
+		stars: raw.stars_count,
+		forks: raw.forks_count,
+		watchers: raw.watchers_count,
+		mergeMethods: raw.allow_merge_commits === void 0 ? void 0 : [
+			...raw.allow_merge_commits ? ["merge"] : [],
+			...raw.allow_squash_merge ? ["squash"] : [],
+			...raw.allow_rebase ? ["rebase"] : [],
+			...raw.allow_rebase_explicit ? ["rebase_merge"] : [],
+			...raw.allow_fast_forward_only_merge ? ["fast_forward_only"] : []
+		],
+		features: raw.has_issues === void 0 ? void 0 : {
+			issues: raw.has_issues,
+			pullRequests: raw.has_pull_requests ?? true,
+			discussions: false,
+			wiki: raw.has_wiki ?? false,
+			projects: raw.has_projects ?? false,
+			releases: raw.has_releases ?? true
+		},
+		permissions: raw.permissions ? {
+			admin: raw.permissions.admin,
+			maintain: raw.permissions.admin,
+			push: raw.permissions.push,
+			triage: raw.permissions.push,
+			pull: raw.permissions.pull
+		} : void 0,
+		raw
+	};
+}
+/** Forgejo and Gitea report `owner`, `admin`, `write`, `read` or `none`; there is no triage or maintain role. */
+function toRole(raw) {
+	switch (raw) {
+		case "owner":
+		case "admin": return "admin";
+		case "write": return "write";
+		case "read": return "read";
+		default: return "none";
+	}
+}
+function toLabel(raw) {
+	return {
+		name: raw.name,
+		colour: raw.color || void 0,
+		description: raw.description || void 0
+	};
+}
+function toMilestone(raw) {
+	return raw ? {
+		id: String(raw.id),
+		title: raw.title,
+		state: raw.state === "closed" ? "closed" : "open",
+		description: raw.description || void 0,
+		dueOn: toDate(raw.due_on),
+		raw
+	} : void 0;
+}
+function toThreadKind(subjectType) {
+	switch (subjectType) {
+		case "Pull":
+		case "PullRequest": return "pull_request";
+		case "Commit": return "commit";
+		case "Issue": return "issue";
+		default: return "other";
+	}
+}
+function toSubjectState(state) {
+	switch (state) {
+		case "open":
+		case "closed":
+		case "merged": return state;
+		default: return "unknown";
+	}
+}
+function numberFromUrl(url) {
+	return /\/(?:issues|pulls|commits|git\/commits)\/([^/?#]+)/.exec(url ?? "")?.[1];
+}
+function toSubject(origin, raw) {
+	const repo = toRepoRef(origin, raw.repository);
+	const kind = toThreadKind(raw.subject.type);
+	if (kind !== "other") return {
+		type: "thread",
+		thread: {
+			...origin,
+			repo,
+			kind,
+			typeRaw: raw.subject.type,
+			number: numberFromUrl(raw.subject.url)
+		}
+	};
+	if (raw.subject.type === "Repository") return {
+		type: "repo",
+		repo
+	};
+	return {
+		type: "other",
+		typeRaw: raw.subject.type,
+		repo,
+		url: raw.subject.url ?? void 0
+	};
+}
+function toNotification(origin, raw) {
+	return {
+		ref: {
+			...origin,
+			id: String(raw.id)
+		},
+		subject: toSubject(origin, raw),
+		subjectTypeRaw: raw.subject.type,
+		reason: "unknown",
+		unread: raw.unread,
+		title: raw.subject.title,
+		subjectState: toSubjectState(raw.subject.state),
+		subjectStateRaw: raw.subject.state,
+		updatedAt: toDate(raw.updated_at) ?? /* @__PURE__ */ new Date(0),
+		url: raw.subject.url ?? raw.url,
+		raw
+	};
+}
+function toThread(ref, raw) {
+	const origin = {
+		forge: ref.forge,
+		instance: ref.instance
+	};
+	const kind = (Boolean(raw.pull_request) || Boolean(raw.head)) && ref.kind === "issue" ? "pull_request" : ref.kind;
+	const state = raw.merged || raw.pull_request?.merged ? "merged" : raw.state === "open" || raw.state === "closed" ? raw.state : "unknown";
+	return {
+		ref: {
+			...ref,
+			kind,
+			externalId: raw.id === void 0 ? ref.externalId : String(raw.id)
+		},
+		kind,
+		title: raw.title,
+		body: raw.body ?? void 0,
+		state,
+		stateRaw: raw.state,
+		isDraft: raw.draft ?? raw.pull_request?.draft ?? false,
+		author: toActor(origin, raw.user),
+		assignees: (raw.assignees ?? []).flatMap((user) => toActor(origin, user) ?? []),
+		reviewers: (raw.requested_reviewers ?? []).flatMap((user) => {
+			const actor = toActor(origin, user);
+			return actor ? [{
+				actor,
+				state: "pending",
+				stateRaw: "requested"
+			}] : [];
+		}),
+		labels: (raw.labels ?? []).map((label) => ({
+			name: label.name,
+			colour: label.color,
+			description: label.description || void 0
+		})),
+		url: raw.html_url,
+		createdAt: toDate(raw.created_at),
+		updatedAt: toDate(raw.updated_at),
+		closedAt: toDate(raw.closed_at),
+		lastActivityAt: toDate(raw.updated_at),
+		locked: raw.is_locked,
+		commentCount: raw.comments,
+		milestone: toMilestone(raw.milestone),
+		branches: raw.head && raw.base ? {
+			head: {
+				ref: raw.head.ref,
+				sha: raw.head.sha,
+				repo: raw.head.repo ? toRepoRef(origin, raw.head.repo) : void 0
+			},
+			base: {
+				ref: raw.base.ref,
+				sha: raw.base.sha
+			},
+			mergeCommitSha: raw.merge_commit_sha ?? void 0
+		} : void 0,
+		raw
+	};
+}
+function toComment(thread, raw) {
+	return {
+		ref: {
+			forge: thread.forge,
+			instance: thread.instance,
+			thread,
+			id: String(raw.id)
+		},
+		body: raw.body ?? "",
+		author: toActor({
+			forge: thread.forge,
+			instance: thread.instance
+		}, raw.user),
+		createdAt: toDate(raw.created_at),
+		updatedAt: toDate(raw.updated_at),
+		url: raw.html_url,
+		raw
+	};
+}
+const EVENT_KINDS$1 = {
+	comment: "comment",
+	review: "review",
+	code_comment: "review_comment",
+	commit_ref: "commit",
+	issue_ref: "referenced",
+	pull_ref: "referenced",
+	change_issue_ref: "referenced",
+	pull_push: "commit",
+	label: "label",
+	close: "state_change",
+	reopen: "state_change",
+	merge_pull: "state_change",
+	pull_request_ready_for_review: "state_change",
+	assignees: "assignment"
+};
+function toEventKind(type) {
+	return EVENT_KINDS$1[type ?? ""] ?? "other";
+}
+function summarise(entry, kind, actor) {
+	const who = actor?.login ?? "someone";
+	switch (kind) {
+		case "comment": return `${who} commented`;
+		case "review": return `${who} reviewed`;
+		case "review_comment": return `${who} commented on a line`;
+		case "commit": return `${who} referenced ${entry.ref_commit_sha?.slice(0, 7) || "a commit"}`;
+		case "referenced": return `${who} referenced this${entry.ref_issue ? ` from #${entry.ref_issue.number}` : ""}`;
+		case "label": return `${who} changed label ${entry.label?.name ?? ""}`.trim();
+		case "state_change": return `${who} ${entry.type ?? "changed state"}`;
+		case "assignment": return `${who} assigned ${entry.assignee?.login ?? ""}`.trim();
+		default: return `${who} ${entry.type ?? "acted"}`;
+	}
+}
+/** `issue_ref`, `pull_ref` and `change_issue_ref` name the thread that mentioned this one. */
+function crossReference(thread, entry) {
+	const source = entry.ref_issue;
+	if (!source) return { type: "referenced" };
+	const [owner = "", name = ""] = source.repository?.full_name.split("/") ?? [];
+	const repo = name ? {
+		forge: thread.forge,
+		instance: thread.instance,
+		owner,
+		name,
+		externalId: source.repository?.id === void 0 ? void 0 : String(source.repository.id)
+	} : thread.repo;
+	return {
+		type: "referenced",
+		from: {
+			forge: thread.forge,
+			instance: thread.instance,
+			repo,
+			kind: source.pull_request ? "pull_request" : "issue",
+			number: String(source.number)
+		},
+		fromRepo: repo
+	};
+}
+function toEvent(thread, entry, source = "poll") {
+	const origin = {
+		forge: thread.forge,
+		instance: thread.instance
+	};
+	const kind = toEventKind(entry.type);
+	const actor = toActor(origin, entry.user);
+	return {
+		...origin,
+		id: String(entry.id ?? `${thread.number ?? ""}-${entry.type}-${entry.created_at}`),
+		kind,
+		kindRaw: entry.type,
+		summary: summarise(entry, kind, actor),
+		occurredAt: toDate(entry.created_at) ?? /* @__PURE__ */ new Date(0),
+		actor,
+		repo: thread.repo,
+		thread,
+		...kind === "referenced" ? { detail: crossReference(thread, entry) } : {},
+		source,
+		payload: entry
+	};
+}
+/** Commit status values. `warning` is informational and neither passes nor fails. */
+function statusState(status) {
+	switch (status) {
+		case "success": return "success";
+		case "failure":
+		case "error": return "failure";
+		case "pending": return "pending";
+		case "warning": return "neutral";
+		default: return "unknown";
+	}
+}
+function toStatusCheck(repo, raw) {
+	const state = statusState(raw.status);
+	return {
+		ref: {
+			forge: repo.forge,
+			instance: repo.instance,
+			repo,
+			id: String(raw.id),
+			type: "status"
+		},
+		name: raw.context,
+		state,
+		stateRaw: raw.status,
+		url: raw.target_url || void 0,
+		startedAt: toDate(raw.created_at),
+		completedAt: state === "pending" ? void 0 : toDate(raw.updated_at),
+		raw
+	};
+}
+function toStatusChecks(repo, raw) {
+	return (raw.statuses ?? []).map((status) => toStatusCheck(repo, status));
+}
+/** Every Actions run and job status behind each normalised state, as the repeated `status` filter takes them. */
+const ACTION_STATES = {
+	pending: [
+		"waiting",
+		"running",
+		"blocked"
+	],
+	success: ["success"],
+	failure: ["failure", "cancelled"],
+	neutral: ["skipped"]
+};
+/** Gitea's statuses and conclusions behind each normalised state, as its repeated `status` filter takes them. */
+const GITEA_ACTION_STATES = {
+	pending: [
+		"queued",
+		"waiting",
+		"in_progress"
+	],
+	success: ["success"],
+	failure: ["failure", "cancelled"],
+	neutral: ["skipped"]
+};
+function stateOf(states) {
+	return new Map(Object.entries(states).flatMap(([state, raws]) => raws.map((raw) => [raw, state])));
+}
+const ACTION_STATE_OF = /* @__PURE__ */ stateOf(ACTION_STATES);
+const GITEA_ACTION_STATE_OF = /* @__PURE__ */ stateOf(GITEA_ACTION_STATES);
+function actionState(status) {
+	return ACTION_STATE_OF.get(status) ?? "unknown";
+}
+function giteaActionState(raw) {
+	return GITEA_ACTION_STATE_OF.get(raw.status === "completed" ? raw.conclusion ?? "" : raw.status) ?? "unknown";
+}
+/** Forgejo and Gitea write the zero Unix time for a run or job that never started or stopped. */
+function actionTime(value) {
+	const date = toDate(value);
+	return date && date.getTime() > 0 ? date : void 0;
+}
+/** `prettyref` is the short ref; pull request runs carry `#<number>` or a bare sha instead of a branch. */
+function actionBranch(raw) {
+	const ref = raw.prettyref;
+	return ref && !ref.startsWith("#") && ref !== raw.commit_sha ? ref : void 0;
+}
+function toActionRun(repo, raw) {
+	const state = actionState(raw.status);
+	return {
+		ref: {
+			forge: repo.forge,
+			instance: repo.instance,
+			repo,
+			id: String(raw.id)
+		},
+		name: raw.workflow_id || raw.title || String(raw.id),
+		state,
+		stateRaw: raw.status,
+		number: raw.index_in_repo === void 0 ? void 0 : String(raw.index_in_repo),
+		eventRaw: raw.trigger_event || raw.event,
+		branch: actionBranch(raw),
+		sha: raw.commit_sha || void 0,
+		url: raw.html_url || void 0,
+		actor: toActor({
+			forge: repo.forge,
+			instance: repo.instance
+		}, raw.trigger_user),
+		createdAt: toDate(raw.created),
+		startedAt: actionTime(raw.started),
+		completedAt: state === "pending" ? void 0 : actionTime(raw.stopped),
+		raw
+	};
+}
+function toActionJob(run, raw) {
+	return {
+		ref: {
+			forge: run.forge,
+			instance: run.instance,
+			repo: run.repo,
+			id: String(raw.id),
+			run
+		},
+		name: raw.name,
+		state: actionState(raw.status),
+		stateRaw: raw.status,
+		url: raw.html_url || void 0,
+		raw
+	};
+}
+function toGiteaActionRun(repo, raw) {
+	const state = giteaActionState(raw);
+	return {
+		ref: {
+			forge: repo.forge,
+			instance: repo.instance,
+			repo,
+			id: String(raw.id)
+		},
+		name: raw.path?.split("@refs/")[0] || raw.display_title || String(raw.id),
+		state,
+		stateRaw: raw.status,
+		number: raw.run_number === void 0 ? void 0 : String(raw.run_number),
+		eventRaw: raw.event,
+		branch: raw.head_branch || void 0,
+		sha: raw.head_sha || void 0,
+		url: raw.html_url || void 0,
+		actor: toActor({
+			forge: repo.forge,
+			instance: repo.instance
+		}, raw.actor),
+		createdAt: toDate(raw.created_at),
+		startedAt: actionTime(raw.started_at),
+		completedAt: state === "pending" ? void 0 : actionTime(raw.completed_at),
+		raw
+	};
+}
+function toGiteaActionJob(run, raw) {
+	const state = giteaActionState(raw);
+	return {
+		ref: {
+			forge: run.forge,
+			instance: run.instance,
+			repo: run.repo,
+			id: String(raw.id),
+			run
+		},
+		name: raw.name,
+		state,
+		stateRaw: raw.status,
+		url: raw.html_url || void 0,
+		startedAt: actionTime(raw.started_at),
+		completedAt: state === "pending" ? void 0 : actionTime(raw.completed_at),
+		raw
+	};
+}
+function toRelease(repo, raw) {
+	const origin = {
+		forge: repo.forge,
+		instance: repo.instance
+	};
+	const ref = {
+		...origin,
+		repo,
+		id: String(raw.id),
+		tag: raw.tag_name
+	};
+	return {
+		ref,
+		name: raw.name || void 0,
+		tag: raw.tag_name,
+		body: raw.body || void 0,
+		isDraft: raw.draft,
+		isPrerelease: raw.prerelease,
+		author: raw.author ? toActor(repo, raw.author) : void 0,
+		publishedAt: raw.draft ? void 0 : toDate(raw.published_at),
+		createdAt: toDate(raw.created_at),
+		url: raw.html_url,
+		assets: raw.assets?.map((asset) => ({
+			...asset.id === void 0 ? {} : { ref: {
+				...origin,
+				repo,
+				release: ref,
+				id: String(asset.id)
+			} },
+			name: asset.name,
+			url: asset.browser_download_url,
+			size: asset.size,
+			downloadCount: asset.download_count
+		})),
+		raw
+	};
+}
+function toReviewComment(thread, raw) {
+	return {
+		ref: {
+			forge: thread.forge,
+			instance: thread.instance,
+			thread,
+			id: String(raw.id)
+		},
+		body: raw.body ?? "",
+		author: toActor(thread, raw.user),
+		path: raw.path,
+		line: raw.position ?? raw.original_position,
+		side: raw.position ? "right" : raw.original_position ? "left" : void 0,
+		createdAt: toDate(raw.created_at),
+		url: raw.html_url,
+		raw
+	};
+}
+function toReview(thread, raw, comments) {
+	return {
+		ref: {
+			forge: thread.forge,
+			instance: thread.instance,
+			thread,
+			id: String(raw.id)
+		},
+		author: toActor(thread, raw.user),
+		state: reviewState(raw.state?.toLowerCase() === "request_changes" ? "changes_requested" : raw.state),
+		stateRaw: raw.state,
+		body: raw.body || void 0,
+		submittedAt: toDate(raw.submitted_at),
+		comments,
+		url: raw.html_url,
+		raw
+	};
+}
+function toChangedFile(raw) {
+	return {
+		path: raw.filename,
+		previousPath: raw.previous_filename,
+		status: toFileStatus(raw.status),
+		statusRaw: raw.status,
+		additions: raw.additions,
+		deletions: raw.deletions
+	};
+}
+function toCommit(repo, raw) {
+	const origin = {
+		forge: repo.forge,
+		instance: repo.instance
+	};
+	return {
+		ref: {
+			...origin,
+			repo,
+			sha: raw.sha
+		},
+		sha: raw.sha,
+		message: raw.commit?.message ?? "",
+		author: {
+			actor: toActor(origin, raw.author),
+			name: raw.commit?.author?.name,
+			email: raw.commit?.author?.email,
+			date: toDate(raw.commit?.author?.date)
+		},
+		committer: {
+			actor: toActor(origin, raw.committer),
+			name: raw.commit?.committer?.name,
+			email: raw.commit?.committer?.email,
+			date: toDate(raw.commit?.committer?.date)
+		},
+		parents: raw.parents?.flatMap((parent) => parent.sha ? [parent.sha] : []) ?? [],
+		url: raw.html_url,
+		...raw.stats ? { stats: {
+			additions: raw.stats.additions ?? 0,
+			deletions: raw.stats.deletions ?? 0,
+			total: raw.stats.total
+		} } : {},
+		...raw.files ? { files: raw.files.map(toChangedFile) } : {},
+		raw
+	};
+}
+function toBranch(raw) {
+	return {
+		name: raw.name,
+		sha: raw.commit?.id ?? "",
+		isProtected: raw.protected,
+		raw
+	};
+}
+function toTag(raw) {
+	return {
+		name: raw.name,
+		sha: raw.commit?.sha ?? raw.id ?? "",
+		raw
+	};
+}
+const TREE_TYPES = {
+	blob: "file",
+	tree: "directory",
+	commit: "submodule"
+};
+function toTreeEntry(raw) {
+	return {
+		path: raw.path,
+		type: raw.mode === "120000" ? "symlink" : TREE_TYPES[raw.type ?? ""] ?? "file",
+		sha: raw.sha,
+		size: raw.size,
+		mode: raw.mode
+	};
+}
+function toWebhook(target, raw) {
+	const nativeEvents = raw.events ?? [];
+	return {
+		ref: {
+			forge: target.forge,
+			instance: target.instance,
+			target,
+			id: String(raw.id)
+		},
+		url: raw.config?.url ?? "",
+		events: eventKindsOf(FORGEJO_NATIVE_EVENTS, nativeEvents),
+		nativeEvents,
+		active: raw.active ?? true,
+		contentType: raw.config?.content_type === "form" ? "form" : "json",
+		createdAt: toDate(raw.created_at),
+		updatedAt: toDate(raw.updated_at),
+		raw
+	};
+}
+//#endregion
+//#region src/forgejo/pages.ts
+/** A full page is followed even when `x-total-count` disagrees, because timelines report the page's own length. */
+function countedNextUrl(url, count, totalHeader) {
+	const next = new URL(url);
+	const page = Number(next.searchParams.get("page")) || 1;
+	const limit = Number(next.searchParams.get("limit")) || void 0;
+	if (count === 0 || limit !== void 0 && count > limit) return;
+	const size = limit ?? count;
+	const total = totalHeader === null ? NaN : Number(totalHeader);
+	if (!(Number.isFinite(total) && (page - 1) * size + count < total) && count !== limit) return;
+	next.searchParams.set("page", String(page + 1));
+	next.searchParams.set("limit", String(Math.min(count, size)));
+	return next.toString();
+}
+/** `fetcher` with `page` and `items` that also continue listings Forgejo and Gitea page without a `Link` header. */
+function countedPages(fetcher) {
+	async function page(path, options = {}) {
+		const result = await fetcher.page(path, options);
+		if (result.cursor?.nextUrl || result.notModified) return result;
+		const nextUrl = countedNextUrl(options.cursor?.nextUrl ? fetcher.resolve(options.cursor.nextUrl) : fetcher.resolve(path, options.query), result.data.length, result.response.headers.get("x-total-count"));
+		return nextUrl ? {
+			...result,
+			cursor: {
+				...result.cursor,
+				nextUrl
+			}
+		} : result;
+	}
+	async function* items(path, options = {}) {
+		let cursor;
+		do {
+			const result = await page(path, {
+				...options,
+				cursor
+			});
+			yield* result.data;
+			cursor = result.notModified ? void 0 : result.cursor;
+		} while (cursor?.nextUrl);
+	}
+	return {
+		...fetcher,
+		page,
+		items
+	};
+}
+//#endregion
+//#region src/forgejo/webhooks.ts
+function verifyForgejoSignature(delivery, secret, names = FORGEJO_HEADERS) {
+	return verifyHmacSignature(delivery, secret, { header: names.signature });
+}
+const EVENT_KINDS = {
+	issue_comment: "comment",
+	pull_request_comment: "comment",
+	pull_request_review_comment: "review_comment",
+	pull_request_review_approved: "review",
+	pull_request_review_rejected: "review",
+	pull_request_review_comment_created: "review_comment",
+	pull_request_label: "label",
+	issue_label: "label",
+	issue_assign: "assignment",
+	pull_request_assign: "assignment"
+};
+function eventKindFor(event, payload) {
+	const mapped = EVENT_KINDS[event];
+	if (mapped) return mapped;
+	if (event === "issues" || event === "pull_request") switch (payload.action) {
+		case "label_updated":
+		case "label_cleared": return "label";
+		case "assigned":
+		case "unassigned": return "assignment";
+		case "opened":
+		case "closed":
+		case "reopened":
+		case "merged": return "state_change";
+		default: return "other";
+	}
+	return "other";
+}
+const ZERO_SHA = /^0+$/;
+function repoLevel(origin, event, payload, who) {
+	switch (event) {
+		case "push": return refEvent(who, {
+			ref: payload.ref ?? "",
+			before: payload.before,
+			after: payload.after,
+			deleted: Boolean(payload.after && ZERO_SHA.test(payload.after)),
+			commits: (payload.commits ?? []).map((commit) => ({
+				sha: commit.id,
+				message: commit.message,
+				author: commit.author?.username ?? commit.author?.name,
+				url: commit.url
+			})),
+			commitCount: payload.total_commits
+		});
+		case "create":
+		case "delete": return {
+			kind: "ref",
+			action: event === "create" ? "created" : "deleted",
+			detail: {
+				type: "ref",
+				ref: payload.ref ?? "",
+				refType: payload.ref_type ?? "branch"
+			},
+			summary: `${who} ${event === "create" ? "created" : "deleted"} ${payload.ref_type ?? "ref"} ${payload.ref ?? ""}`.trim()
+		};
+		case "release":
+			if (payload.action !== "published" || !payload.release || !payload.repository) return;
+			return {
+				kind: "release",
+				action: "published",
+				detail: {
+					type: "release",
+					release: {
+						...origin,
+						repo: toRepoRef(origin, payload.repository),
+						id: String(payload.release.id),
+						tag: payload.release.tag_name
+					},
+					name: payload.release.name
+				},
+				summary: `${who} published ${payload.release.name || payload.release.tag_name || "a release"}`
+			};
+		default: return;
+	}
+}
+function detailOf(kind, event, thread, origin, payload) {
+	const comment = payload.comment;
+	const commentRef = comment?.id !== void 0 && thread ? {
+		...origin,
+		thread,
+		id: String(comment.id)
+	} : void 0;
+	switch (kind) {
+		case "comment": return {
+			type: "comment",
+			comment: commentRef,
+			body: comment?.body
+		};
+		case "review_comment": return {
+			type: "review_comment",
+			comment: commentRef,
+			body: comment?.body,
+			path: comment?.path,
+			line: comment?.line
+		};
+		case "review": {
+			const stateRaw = event.replace("pull_request_review_", "");
+			return {
+				type: "review",
+				state: reviewState(stateRaw === "rejected" ? "changes_requested" : stateRaw),
+				stateRaw,
+				body: payload.review?.content
+			};
+		}
+		case "label": return payload.label?.name ? {
+			type: "label",
+			label: payload.label.name
+		} : void 0;
+		case "assignment": return {
+			type: "assignment",
+			assignee: toActor(origin, payload.assignee)
+		};
+		case "state_change": return {
+			type: "state_change",
+			state: payload.pull_request?.merged ? "merged" : payload.action === "closed" ? "closed" : "open",
+			draft: payload.pull_request?.draft
+		};
+		default: return;
+	}
+}
+function translateForgejoWebhook(origin, delivery, names = FORGEJO_HEADERS) {
+	const event = firstHeader(delivery, names.event);
+	if (!event) throw new WebhookVerificationError(`Missing ${names.event[0]} header`, origin);
+	const deliveryId = firstHeader(delivery, names.delivery) ?? crypto.randomUUID();
+	const payload = JSON.parse(bodyText(delivery.body));
+	const repo = payload.repository ? toRepoRef(origin, payload.repository) : void 0;
+	const actor = toActor(origin, payload.sender);
+	const who = actor?.login ?? "someone";
+	const level = repoLevel(origin, event, payload, who);
+	if (level) return [{
+		...origin,
+		id: deliveryId,
+		kind: level.kind,
+		action: level.action,
+		kindRaw: payload.action ? `${event}.${payload.action}` : event,
+		summary: level.summary,
+		occurredAt: toDate(payload.commits?.at(-1)?.timestamp ?? payload.release?.published_at) ?? /* @__PURE__ */ new Date(),
+		actor,
+		repo,
+		detail: level.detail,
+		source: "webhook",
+		payload
+	}];
+	const subject = payload.pull_request ?? payload.issue;
+	const isPull = Boolean(payload.pull_request || payload.is_pull || payload.issue?.pull_request);
+	const thread = repo && subject ? {
+		...origin,
+		repo,
+		kind: isPull ? "pull_request" : "issue",
+		number: String(subject.number)
+	} : void 0;
+	const kind = eventKindFor(event, payload);
+	return [{
+		...origin,
+		id: deliveryId,
+		kind,
+		kindRaw: payload.action ? `${event}.${payload.action}` : event,
+		action: payload.action === "closed" && payload.pull_request?.merged ? "merged" : eventAction(payload.action),
+		actionRaw: payload.action,
+		detail: detailOf(kind, event, thread, origin, payload),
+		summary: `${who} ${payload.action ? `${payload.action} ` : ""}${event}`.trim(),
+		occurredAt: toDate(payload.comment?.created_at) ?? /* @__PURE__ */ new Date(),
+		actor,
+		repo,
+		thread,
+		source: "webhook",
+		payload
+	}];
+}
+/** Handlers for one deployment family; Gitea differs from Forgejo only in its header names. */
+function forgejoWebhooks(profile) {
+	return ({ options, origin }) => ({
+		events: FORGEJO_WEBHOOK_EVENTS,
+		verify: (delivery) => verifyForgejoSignature(delivery, options.webhookSecret, profile.headers),
+		translate: (delivery) => translateForgejoWebhook(origin, delivery, profile.headers)
+	});
+}
+//#endregion
+//#region src/forgejo/index.ts
+const FORGEJO_PROFILE = {
+	forge: "forgejo",
+	defaultBaseUrl: "https://codeberg.org",
+	headers: FORGEJO_HEADERS
+};
+const ISSUE_AND_PULL = {
+	issue: true,
+	pull_request: true
+};
+/** Forgejo versions with the Actions runs API, and with run jobs and job logs. */
+const FORGEJO_ACTION_RUNS = "12.0";
+const FORGEJO_ACTION_JOBS = "16.0";
+/** Gitea versions with runs and their jobs, and with job logs. */
+const GITEA_ACTION_RUNS = "1.25";
+const GITEA_ACTION_LOGS = "1.24";
+/** Timelines send no usable count, so only a full page of an explicit size shows that another follows. */
+const TIMELINE_PAGE_SIZE = 50;
+/** Whether `user` has `login`, in any case; `true` when no login is wanted. Forgejo's issue search ignores `created_by` and `assigned_by`. */
+function sameLogin(user, login) {
+	return !login || user?.login.toLowerCase() === login.toLowerCase();
+}
+const FORGEJO_RESERVED_PATHS = [
+	"-",
+	".well-known",
+	"admin",
+	"api",
+	"assets",
+	"attachments",
+	"avatars",
+	"captcha",
+	"explore",
+	"issues",
+	"login",
+	"milestones",
+	"notifications",
+	"org",
+	"pulls",
+	"repo",
+	"repo-avatars",
+	"search",
+	"user"
+];
+/** The Forgejo implementation for one deployment family. Shared by `forgejo()` and `gitea()`. */
+function forgejoDefinition(profile) {
+	return {
+		forge: profile.forge,
+		baseUrl: profile.defaultBaseUrl,
+		anonymous: true,
+		apiPath: "/api/v1",
+		headers: { accept: "application/json" },
+		authHeaders: ({ options: { auth } }) => auth?.type === "token" ? async () => ({ authorization: `token ${await resolveToken(auth)}` }) : void 0,
+		setup: (ctx) => setupForgejo(ctx, profile)
+	};
+}
+function setupForgejo({ options, origin, fetcher: baseFetcher, baseUrl }, profile) {
+	const context = origin;
+	/** Collaborators, assignees, reviewers and permissions are served only to signed-in users. */
+	const anonymous = options.auth?.type === "anonymous";
+	const fetcher = countedPages(baseFetcher);
+	const list = createListing(fetcher, "limit");
+	async function readUser(path, signal) {
+		const { data } = await fetcher.json(path, { signal });
+		return {
+			...toActor(origin, data),
+			bio: data.description || void 0,
+			location: data.location || void 0,
+			websiteUrl: data.website || void 0,
+			createdAt: toDate(data.created),
+			followers: data.followers_count,
+			following: data.following_count,
+			raw: data
+		};
+	}
+	function repoPath(repo) {
+		return `/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.name)}`;
+	}
+	function threadPath(ref) {
+		switch (ref.kind) {
+			case "pull_request": return `${repoPath(ref.repo)}/pulls/${encodeURIComponent(ref.number)}`;
+			case "commit": return `${repoPath(ref.repo)}/git/commits/${encodeURIComponent(ref.number)}`;
+			case "discussion": throw new UnsupportedOperationError(`${profile.forge} has no discussions`, context);
+			default: return `${repoPath(ref.repo)}/issues/${encodeURIComponent(ref.number)}`;
+		}
+	}
+	const currentUser = memo(() => fetcher.json("/user").then((result) => result.data));
+	/** Labels are addressed by id in writes, so names are resolved once per repo. */
+	/** Forgejo and Gitea address reactions on issues and on comments with the same body. */
+	function reactionPath(target) {
+		return "thread" in target ? `${repoPath(target.thread.repo)}/issues/comments/${encodeURIComponent(target.id)}/reactions` : `${issuePath(requireIssueOrPull(target, context, "react to"))}/reactions`;
+	}
+	async function setReaction(target, reaction, method, options) {
+		await fetcher.raw(reactionPath(target), {
+			method,
+			json: { content: reaction },
+			signal: options?.signal
+		});
+	}
+	const labelIdsOf = memoBy(async (path) => {
+		const map = /* @__PURE__ */ new Map();
+		for await (const label of fetcher.items(path, { query: { limit: 50 } })) map.set(label.name, label.id);
+		return map;
+	});
+	/** Labels an organisation shares with its repositories; none for a user, whose `/orgs` route is a 404. */
+	const orgLabelIdsOf = memoBy(async (owner) => {
+		try {
+			return await labelIdsOf(`/orgs/${encodeURIComponent(owner)}/labels`);
+		} catch (error) {
+			if (error instanceof NotFoundError) return /* @__PURE__ */ new Map();
+			throw error;
+		}
+	});
+	async function resolveLabels(repo, names) {
+		const map = await labelIdsOf(`${repoPath(repo)}/labels`);
+		const shared = names.some((name) => !map.has(name)) ? await orgLabelIdsOf(repo.owner) : void 0;
+		return names.map((name) => {
+			const id = map.get(name) ?? shared?.get(name);
+			if (id === void 0) throw new UnsupportedOperationError(`No label named ${name} in ${repo.owner}/${repo.name}`, context);
+			return id;
+		});
+	}
+	async function notificationPage(listOptions = {}) {
+		const result = await fetcher.json(listOptions.cursor?.nextUrl ?? "/notifications", {
+			query: listOptions.cursor?.nextUrl ? void 0 : {
+				all: listOptions.all ?? false,
+				since: listOptions.since?.toISOString(),
+				limit: listOptions.perPage
+			},
+			signal: listOptions.signal
+		});
+		return {
+			items: (result.data ?? []).map((raw) => toNotification(origin, raw)),
+			cursor: result.cursor,
+			notModified: result.notModified
+		};
+	}
+	async function setStatus(ref, status, options) {
+		await fetcher.raw(`/notifications/threads/${encodeURIComponent(ref.id)}`, {
+			method: "PATCH",
+			query: { "to-status": status },
+			signal: options?.signal
+		});
+	}
+	async function issueTarget(ref, { thread, signal }) {
+		if (thread) {
+			const resolved = requireThread(thread, context);
+			if (resolved.kind !== "issue" && resolved.kind !== "pull_request") throw new UnsupportedOperationError("Only issue and pull request threads can be unsubscribed from", context);
+			return {
+				owner: resolved.repo.owner,
+				name: resolved.repo.name,
+				number: resolved.number
+			};
+		}
+		const { data } = await fetcher.json(`/notifications/threads/${encodeURIComponent(ref.id)}`, { signal });
+		const number = numberFromUrl(data.subject.url);
+		if (!number || toThreadKind(data.subject.type) === "commit") throw new UnsupportedOperationError("Only issue and pull request threads can be unsubscribed from", context);
+		const [owner = "", name = ""] = data.repository.full_name.split("/");
+		return {
+			owner,
+			name,
+			number
+		};
+	}
+	async function subscriptionPath(target) {
+		const user = await currentUser();
+		return `${repoPath(target)}/issues/${encodeURIComponent(target.number)}/subscriptions/${encodeURIComponent(user.login)}`;
+	}
+	async function unsubscribe(ref, writeOptions = {}) {
+		await fetcher.raw(await subscriptionPath(await issueTarget(ref, writeOptions)), {
+			method: "DELETE",
+			signal: writeOptions.signal
+		});
+	}
+	function issuePath(ref) {
+		return `${repoPath(ref.repo)}/issues/${encodeURIComponent(ref.number)}`;
+	}
+	async function setState(thread, state, options) {
+		await fetcher.raw(issuePath(requireIssueOrPull(thread, context, state === "open" ? "reopen" : "close")), {
+			method: "PATCH",
+			json: { state },
+			signal: options?.signal
+		});
+	}
+	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);
+		const pull = `${repoPath(ref.repo)}/pulls/${encodeURIComponent(ref.number)}`;
+		let method = mergeOptions.method;
+		if (!method) {
+			const { data: repo } = await fetcher.json(repoPath(ref.repo), { signal: mergeOptions.signal });
+			method = soleMergeMethod({
+				merge: repo.allow_merge_commits,
+				rebase: repo.allow_rebase,
+				rebase_merge: repo.allow_rebase_explicit,
+				squash: repo.allow_squash_merge,
+				fast_forward_only: repo.allow_fast_forward_only_merge
+			}, context);
+		}
+		await hooks.beforeMerge?.();
+		await fetcher.raw(`${pull}/merge`, {
+			method: "POST",
+			json: {
+				Do: method.replaceAll("_", "-"),
+				MergeTitleField: mergeOptions.title,
+				MergeMessageField: mergeOptions.message,
+				head_commit_id: mergeOptions.sha,
+				merge_when_checks_succeed: mergeOptions.whenChecksPass
+			},
+			mapError: toMergeError,
+			signal: mergeOptions.signal
+		});
+	}
+	const REVIEW_EVENTS = {
+		approve: "APPROVED",
+		request_changes: "REQUEST_CHANGES",
+		comment: "COMMENT"
+	};
+	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;
+	}
+	function pullPath(ref) {
+		return `${repoPath(ref.repo)}/pulls/${encodeURIComponent(ref.number)}`;
+	}
+	function reviewCommentInput(comments) {
+		return comments?.map((comment) => ({
+			path: comment.path,
+			body: comment.body,
+			...comment.side === "left" ? { old_position: comment.line } : { new_position: comment.line }
+		}));
+	}
+	async function createReview(thread, input, options) {
+		const ref = requirePull(thread, "reviewed");
+		const { data } = await fetcher.json(`${pullPath(ref)}/reviews`, {
+			method: "POST",
+			json: {
+				event: input.event ? REVIEW_EVENTS[input.event] : void 0,
+				body: input.body ?? "",
+				comments: reviewCommentInput(input.comments)
+			},
+			signal: options?.signal
+		});
+		return toReview(ref, data, []);
+	}
+	async function get(thread, options) {
+		const ref = requireThread(thread, context);
+		const { data } = await fetcher.json(threadPath(ref), { signal: options?.signal });
+		const result = toThread(ref, data);
+		if (ref.kind === "pull_request" && data.head?.sha) try {
+			const checks = await statusChecks(ref.repo, data.head.sha, options?.signal);
+			result.checks = summariseChecks(checks.map((check) => check.state));
+		} catch (error) {
+			if (!(error instanceof ForgeError)) throw error;
+			result.warnings = [...result.warnings ?? [], toWarning("checks_unreadable", error, ref.number)];
+		}
+		return result;
+	}
+	const STATUS_STATES = {
+		pending: "pending",
+		success: "success",
+		failure: "failure",
+		neutral: "success",
+		unknown: "pending"
+	};
+	async function statusChecks(repo, sha, signal) {
+		const { data } = await fetcher.json(`${repoPath(repo)}/commits/${sha}/status`, { signal });
+		return toStatusChecks(repo, data);
+	}
+	function milestonesPage(repo, listOptions = {}) {
+		return list(`${repoPath(repo)}/milestones`, listOptions, (raw) => toMilestone(raw), { query: { state: listOptions.state ?? "open" } });
+	}
+	async function releasesPage(repo, listOptions = {}) {
+		return list(`${repoPath(repo)}/releases`, listOptions, (raw) => toRelease(repo, raw));
+	}
+	async function writeRelease(repo, path, method, input, options) {
+		const { data } = await fetcher.json(path, {
+			method,
+			json: {
+				tag_name: input.tag,
+				target_commitish: input.target,
+				name: input.name,
+				body: input.body,
+				draft: input.draft,
+				prerelease: input.prerelease
+			},
+			signal: options?.signal
+		});
+		return toRelease(repo, method === "POST" ? {
+			...data,
+			assets: []
+		} : data);
+	}
+	async function listPage(repo, query = {}) {
+		const warnings = [];
+		if (query.kind === "discussion") return {
+			items: [],
+			warnings: [{
+				code: "kind_unsupported",
+				message: `${profile.forge} has no discussions`
+			}]
+		};
+		const sort = query.sort ?? "created";
+		const direction = query.direction ?? "desc";
+		if (!query.cursor && (sort !== "created" || direction !== "desc")) warnings.push({
+			code: "sort_unsupported",
+			message: `${profile.forge} lists repository issues newest first only`
+		});
+		const createdAfter = query.createdAfter?.getTime();
+		const result = await fetcher.page(`${repoPath(repo)}/issues`, {
+			query: {
+				state: query.state === "merged" ? "closed" : query.state ?? "open",
+				type: query.kind === "pull_request" ? "pulls" : query.kind === "issue" ? "issues" : void 0,
+				labels: query.labels?.join(","),
+				created_by: query.author,
+				assigned_by: query.assignee,
+				since: query.since?.toISOString(),
+				limit: query.perPage
+			},
+			cursor: query.cursor,
+			signal: query.signal
+		});
+		const older = (raw) => createdAfter !== void 0 && (Date.parse(raw.created_at ?? "") || 0) < createdAfter;
+		const unmerged = (raw) => query.state === "merged" && !raw.pull_request?.merged;
+		const page = toPage(result, (raw) => older(raw) || unmerged(raw) || !hasEveryLabel(raw.labels, query.labels) ? void 0 : toThread({
+			...origin,
+			repo,
+			kind: raw.pull_request ? "pull_request" : "issue",
+			number: String(raw.number)
+		}, raw), warnings);
+		return (result.data ?? []).some(older) ? {
+			...page,
+			cursor: void 0
+		} : page;
+	}
+	/** Repository hooks, or organisation hooks for a namespace ref. */
+	function hooksPath(target) {
+		return isNamespaceRef(target) ? `/orgs/${encodeURIComponent(target.owner)}/hooks` : `${repoPath(target)}/hooks`;
+	}
+	async function searchThreadsPage(query) {
+		const warnings = [];
+		if (!query.cursor && query.involves) warnings.push({
+			code: "filter_unsupported",
+			message: `${profile.forge} has no involves filter; it was ignored`
+		});
+		if (!query.cursor && query.sort && query.sort !== "relevance") warnings.push({
+			code: "sort_unsupported",
+			message: `${profile.forge} searches issues newest first only`
+		});
+		const result = await fetcher.page("/repos/issues/search", {
+			query: {
+				q: query.text,
+				type: query.kind === "pull_request" ? "pulls" : query.kind === "issue" ? "issues" : void 0,
+				state: query.state ?? "all",
+				labels: query.labels?.join(","),
+				created_by: query.author,
+				assigned_by: query.assignee,
+				since: query.since?.toISOString(),
+				owner: query.repo?.owner,
+				limit: query.perPage
+			},
+			cursor: query.cursor,
+			signal: query.signal
+		});
+		return toPage(result, (raw) => {
+			const [owner = "", name = ""] = raw.repository?.full_name.split("/") ?? [];
+			const repo = query.repo ?? (name ? {
+				...origin,
+				owner,
+				name,
+				externalId: raw.repository?.id === void 0 ? void 0 : String(raw.repository.id)
+			} : void 0);
+			if (!repo || !hasEveryLabel(raw.labels, query.labels) || !sameLogin(raw.user, query.author) || query.assignee && !raw.assignees?.some((user) => sameLogin(user, query.assignee)) || query.repo && raw.repository && raw.repository.full_name !== `${query.repo.owner}/${query.repo.name}`) return;
+			return toThread({
+				...origin,
+				repo,
+				kind: raw.pull_request ? "pull_request" : "issue",
+				number: String(raw.number)
+			}, raw);
+		}, warnings);
+	}
+	const isGitea = profile.forge === "gitea";
+	/** Codeberg and gitea.com run a current release, so only a self-hosted instance waits for its version. */
+	function actions(forgejoMinimum, giteaMinimum) {
+		const minimum = isGitea ? giteaMinimum : forgejoMinimum;
+		return hostOf(baseUrl) === hostOf(profile.defaultBaseUrl) ? true : ({ version }) => versionAtLeast(version, minimum);
+	}
+	/** Gitea lists runs and serves job logs only with a token. */
+	const giteaAnonymous = isGitea && anonymous;
+	/** One page of an Actions listing, read from `key` and continued from `total_count` when no `Link` header is sent. */
+	async function actionsPage(path, key, query, pageOptions) {
+		const url = pageOptions.cursor?.nextUrl ? fetcher.resolve(pageOptions.cursor.nextUrl) : fetcher.resolve(path, query);
+		return fetcher.page(path, {
+			query,
+			cursor: pageOptions.cursor,
+			signal: pageOptions.signal,
+			select: (body, next) => {
+				const listing = body;
+				const items = listing[key] ?? [];
+				return {
+					items,
+					next: next ?? countedNextUrl(url, items.length, listing.total_count === void 0 ? null : String(listing.total_count))
+				};
+			}
+		});
+	}
+	async function runsPage(repo, query = {}) {
+		const states = isGitea ? GITEA_ACTION_STATES : ACTION_STATES;
+		const statuses = query.state ? `?${states[query.state].map((status) => `status=${status}`).join("&")}` : "";
+		const path = `${repoPath(repo)}/actions/runs${statuses}`;
+		if (isGitea) return toPage(await actionsPage(path, "workflow_runs", {
+			branch: query.branch,
+			page: 1,
+			limit: query.perPage ?? 50
+		}, query), (raw) => toGiteaActionRun(repo, raw));
+		const result = await actionsPage(path, "workflow_runs", {
+			ref: query.branch ? `refs/heads/${query.branch}` : void 0,
+			page: 1,
+			limit: query.perPage ?? 50
+		}, query);
+		return toPage(result, (raw) => query.branch && actionBranch(raw) !== query.branch ? void 0 : toActionRun(repo, raw));
+	}
+	async function jobsPage(ref, listOptions = {}) {
+		const path = `${repoPath(ref.repo)}/actions/runs/${encodeURIComponent(ref.id)}/jobs`;
+		if (isGitea) return toPage(await actionsPage(path, "jobs", {
+			page: 1,
+			limit: listOptions.perPage ?? 50
+		}, listOptions), (raw) => toGiteaActionJob(ref, raw));
+		const { data } = await fetcher.json(path, { signal: listOptions.signal });
+		return { items: (data ?? []).map((raw) => toActionJob(ref, raw)) };
+	}
+	async function searchReposPage(query) {
+		const result = await fetcher.page("/repos/search", {
+			query: {
+				q: query.text,
+				owner: query.owner,
+				sort: query.sort === "stars" ? "stars" : query.sort === "created" ? "created" : query.sort === "updated" ? "updated" : void 0,
+				order: query.direction,
+				limit: query.perPage
+			},
+			cursor: query.cursor,
+			signal: query.signal,
+			select: (body, next) => ({
+				items: body.data,
+				next
+			})
+		});
+		return toPage(result, (raw) => toRepo(origin, raw));
+	}
+	return {
+		traits: {
+			eventKinds: "native",
+			authKinds: ["token", "anonymous"]
+		},
+		search: {
+			threadsPage: verb(true, searchThreadsPage),
+			reposPage: verb(true, searchReposPage)
+		},
+		probeVersion: async () => (await fetcher.json("/version")).data.version,
+		users: {
+			get: verb(true, (login, options) => readUser(`/users/${encodeURIComponent(login)}`, options?.signal)),
+			me: verb(true, (options) => readUser("/user", options?.signal))
+		},
+		repos: {
+			get: verb(true, async (ref, options) => toRepo(origin, (await fetcher.json(repoPath(ref), { signal: options?.signal })).data)),
+			listPage: verb(true, (listOptions = {}) => list("/user/repos", listOptions, (raw) => toRepo(origin, raw))),
+			labelsPage: verb(true, (repo, listOptions = {}) => list(`${repoPath(repo)}/labels`, listOptions, toLabel)),
+			createLabel: verb(true, async (repo, label, options) => toLabel((await fetcher.json(`${repoPath(repo)}/labels`, {
+				method: "POST",
+				json: {
+					name: label.name,
+					color: hexColour(label.colour, "#"),
+					description: label.description
+				},
+				signal: options?.signal
+			})).data)),
+			milestonesPage: verb(true, milestonesPage),
+			collaboratorsPage: verb(!anonymous, (repo, listOptions = {}) => list(`${repoPath(repo)}/collaborators`, listOptions, (raw) => ({
+				actor: toActor(origin, raw),
+				role: "read",
+				raw
+			}))),
+			permissionFor: verb(!anonymous, async (repo, actor, options) => {
+				const { data } = await fetcher.json(`${repoPath(repo)}/collaborators/${encodeURIComponent(actorLogin(actor))}/permission`, { signal: options?.signal });
+				return toRole(data.role_name ?? data.permission);
+			}),
+			addCollaborator: verb(true, async (repo, actor, role, options) => {
+				await fetcher.raw(`${repoPath(repo)}/collaborators/${encodeURIComponent(actorLogin(actor))}`, {
+					method: "PUT",
+					json: { permission: role === "admin" ? "admin" : role === "read" || role === "triage" ? "read" : "write" },
+					signal: options?.signal
+				});
+			}),
+			assignableUsersPage: verb(!anonymous, (repo, listOptions = {}) => list(`${repoPath(repo)}/assignees`, listOptions, (raw) => toActor(origin, raw))),
+			reviewerCandidatesPage: verb(!anonymous, (thread, listOptions = {}) => list(`${repoPath(requireThread(thread, context).repo)}/reviewers`, listOptions, (raw) => toActor(origin, raw)))
+		},
+		notifications: {
+			listPage: verb(true, notificationPage),
+			markRead: verb(true, (ref, options) => setStatus(ref, "read", options)),
+			markDone: verb("emulated", async (ref, writeOptions) => {
+				await setStatus(ref, "read", writeOptions);
+				await unsubscribe(ref, writeOptions);
+			}),
+			unsubscribe: verb(true, unsubscribe),
+			markAllRead: verb(true, async (bulk = {}) => {
+				await fetcher.raw(bulk.repo ? `${repoPath(bulk.repo)}/notifications` : "/notifications", {
+					method: "PUT",
+					query: {
+						"last_read_at": bulk.before?.toISOString(),
+						"to-status": "read"
+					},
+					signal: bulk.signal
+				});
+			}),
+			unreadCount: verb(true, async (options) => (await fetcher.json("/notifications/new", { signal: options?.signal })).data.new)
+		},
+		checks: {
+			list: verb(true, async (repo, sha, options) => ({ items: await statusChecks(repo, sha, options?.signal) })),
+			report: verb(true, async (repo, sha, input, options) => toStatusCheck(repo, (await fetcher.json(`${repoPath(repo)}/statuses/${sha}`, {
+				method: "POST",
+				json: {
+					state: STATUS_STATES[input.state],
+					context: input.name,
+					description: input.description,
+					target_url: input.url
+				},
+				signal: options?.signal
+			})).data))
+		},
+		ci: {
+			runsPage: verb(giteaAnonymous ? false : actions(FORGEJO_ACTION_RUNS, GITEA_ACTION_RUNS), runsPage),
+			run: verb(actions(FORGEJO_ACTION_RUNS, GITEA_ACTION_RUNS), async (ref, options) => {
+				const path = `${repoPath(ref.repo)}/actions/runs/${encodeURIComponent(ref.id)}`;
+				return isGitea ? toGiteaActionRun(ref.repo, (await fetcher.json(path, { signal: options?.signal })).data) : toActionRun(ref.repo, (await fetcher.json(path, { signal: options?.signal })).data);
+			}),
+			jobsPage: verb(actions(FORGEJO_ACTION_JOBS, GITEA_ACTION_RUNS), jobsPage),
+			log: verb(giteaAnonymous ? false : actions(FORGEJO_ACTION_JOBS, GITEA_ACTION_LOGS), async (ref, options) => (await fetcher.stream(`${repoPath(ref.repo)}/actions/jobs/${encodeURIComponent(ref.id)}/logs`, { signal: options?.signal })).body)
+		},
+		contents: {
+			file: verb(true, async (repo, path, fileOptions = {}) => {
+				const encoded = path.split("/").map(encodeURIComponent).join("/");
+				const { data } = await fetcher.json(`${repoPath(repo)}/contents/${encoded}`, {
+					query: { ref: fileOptions.ref },
+					signal: fileOptions.signal
+				});
+				const file = {
+					path: data.path,
+					sha: data.sha,
+					size: data.size,
+					url: data.html_url ?? void 0
+				};
+				if (data.encoding === "base64" && data.content) return toFileContent(fromBase64(data.content), file, fileOptions, context);
+				const response = await fetcher.raw(`${repoPath(repo)}/raw/${encoded}`, {
+					query: { ref: fileOptions.ref },
+					signal: fileOptions.signal
+				});
+				return toFileContent(new Uint8Array(await response.arrayBuffer()), file, fileOptions, context);
+			}),
+			treePage: verb(true, async (repo, treeOptions = {}) => {
+				const ref = treeOptions.ref ?? "HEAD";
+				const { data, response } = await fetcher.json(`${repoPath(repo)}/git/trees/${encodeURIComponent(ref)}`, {
+					query: {
+						recursive: treeOptions.recursive ? "true" : void 0,
+						per_page: treeOptions.perPage
+					},
+					signal: treeOptions.signal
+				});
+				const prefix = treeOptions.path?.replace(/^\/|\/$/g, "");
+				const entries = (data.tree ?? []).filter((entry) => !prefix || entry.path.startsWith(`${prefix}/`));
+				const warnings = data.truncated ? [{
+					code: "tree_truncated",
+					message: `${profile.forge} truncated the tree; read it directory by directory instead`,
+					subject: ref
+				}] : [];
+				return toPage({
+					data: entries,
+					response,
+					notModified: false
+				}, toTreeEntry, warnings);
+			}),
+			branchesPage: verb(true, (repo, listOptions = {}) => list(`${repoPath(repo)}/branches`, listOptions, toBranch)),
+			tagsPage: verb(true, (repo, listOptions = {}) => list(`${repoPath(repo)}/tags`, listOptions, toTag)),
+			resolveRef: verb(true, async (repo, ref, options) => {
+				const { data } = await fetcher.json(`${repoPath(repo)}/commits`, {
+					query: {
+						sha: ref,
+						limit: 1,
+						stat: "false"
+					},
+					signal: options?.signal
+				});
+				const sha = data[0]?.sha;
+				if (!sha) throw new NotFoundError(`${profile.forge} has no commit for ${ref}`, 404, "", context);
+				return sha;
+			}),
+			commitsPage: verb(true, (repo, query = {}) => list(`${repoPath(repo)}/commits`, query, (raw) => toCommit(repo, raw), { query: {
+				sha: query.ref,
+				path: query.path,
+				since: query.since?.toISOString(),
+				until: query.until?.toISOString()
+			} })),
+			commit: verb(true, async (repo, sha, options) => toCommit(repo, (await fetcher.json(`${repoPath(repo)}/git/commits/${sha}`, {
+				query: {
+					stat: "true",
+					files: "true"
+				},
+				signal: options?.signal
+			})).data)),
+			compare: verb(true, async (repo, base, head, options) => {
+				const { data } = await fetcher.json(`${repoPath(repo)}/compare/${encodeURIComponent(base)}...${encodeURIComponent(head)}`, { signal: options?.signal });
+				return {
+					base,
+					head,
+					aheadBy: data.total_commits ?? data.commits?.length,
+					commits: (data.commits ?? []).map((raw) => toCommit(repo, raw)),
+					files: (data.files ?? []).map(toChangedFile),
+					raw: data
+				};
+			})
+		},
+		releases: {
+			listPage: verb(true, releasesPage),
+			get: verb(true, async (ref, options) => toRelease(ref.repo, (await fetcher.json(`${repoPath(ref.repo)}/releases/${encodeURIComponent(ref.id)}`, { signal: options?.signal })).data)),
+			getByTag: verb(true, async (repo, tag, options) => toRelease(repo, (await fetcher.json(`${repoPath(repo)}/releases/tags/${encodeURIComponent(tag)}`, { signal: options?.signal })).data)),
+			downloadAsset: verb(true, async (ref, downloadOptions = {}) => {
+				const { data } = await fetcher.json(`${repoPath(ref.repo)}/releases/${encodeURIComponent(ref.release.id)}/assets/${encodeURIComponent(ref.id)}`, { signal: downloadOptions.signal });
+				return (await fetcher.stream(data.browser_download_url, { signal: downloadOptions.signal })).body;
+			}),
+			latest: verb(true, async (repo, options) => {
+				try {
+					return toRelease(repo, (await fetcher.json(`${repoPath(repo)}/releases/latest`, { signal: options?.signal })).data);
+				} catch (error) {
+					if (error instanceof NotFoundError) return;
+					throw error;
+				}
+			}),
+			create: verb(true, (repo, input, options) => writeRelease(repo, `${repoPath(repo)}/releases`, "POST", input, options)),
+			update: verb(true, (ref, update, options) => writeRelease(ref.repo, `${repoPath(ref.repo)}/releases/${encodeURIComponent(ref.id)}`, "PATCH", update, options))
+		},
+		threads: {
+			checks: perKind({ pull_request: true }, async (thread, options) => {
+				const ref = requireThread(thread, context);
+				const { data } = await fetcher.json(threadPath(ref), { signal: options?.signal });
+				return { items: data.head?.sha ? await statusChecks(ref.repo, data.head.sha, options?.signal) : [] };
+			}),
+			reviewsPage: verb(true, async (thread, listOptions = {}) => {
+				const ref = requirePull(thread, "reviewed");
+				const result = await fetcher.page(`${pullPath(ref)}/reviews`, {
+					query: { limit: listOptions.perPage },
+					cursor: listOptions.cursor,
+					signal: listOptions.signal
+				});
+				return {
+					items: await Promise.all((result.data ?? []).map(async (raw) => {
+						const comments = raw.comments_count === 0 ? [] : (await fetcher.json(`${pullPath(ref)}/reviews/${encodeURIComponent(raw.id)}/comments`, { signal: listOptions.signal })).data ?? [];
+						return toReview(ref, raw, comments.map((comment) => toReviewComment(ref, comment)));
+					})),
+					cursor: result.cursor
+				};
+			}),
+			filesPage: verb(true, (ref, listOptions = {}) => list(`${pullPath(requirePull(ref, "read for changed files"))}/files`, listOptions, toChangedFile)),
+			commitsPage: verb(true, (ref, listOptions = {}) => list(`${pullPath(requirePull(ref, "read for commits"))}/commits`, listOptions, (raw) => toCommit(ref.repo, raw))),
+			createReview: verb(true, createReview),
+			submitReview: verb(true, async (ref, event, body, options) => {
+				const pull = requirePull(ref.thread, "reviewed");
+				const { data } = await fetcher.json(`${pullPath(pull)}/reviews/${encodeURIComponent(ref.id)}`, {
+					method: "POST",
+					json: {
+						event: REVIEW_EVENTS[event],
+						body: body ?? ""
+					},
+					signal: options?.signal
+				});
+				return toReview(pull, data, []);
+			}),
+			get: perKind({
+				issue: true,
+				pull_request: true,
+				commit: true
+			}, get),
+			getMany: verb(true, (refs, options) => getManyConcurrently(refs, get, options)),
+			listPage: perKind(ISSUE_AND_PULL, listPage),
+			eventsPage: verb(true, async (thread, listOptions = {}) => {
+				const ref = requireThread(thread, context);
+				if (ref.kind === "commit") return { items: [] };
+				return list(`${issuePath(ref)}/timeline`, {
+					perPage: TIMELINE_PAGE_SIZE,
+					...listOptions
+				}, (entry) => toEvent(ref, entry));
+			}),
+			commentsPage: perKind(ISSUE_AND_PULL, async (thread, listOptions = {}) => {
+				const ref = requireIssueOrPull(thread, context, "list comments on");
+				return list(`${issuePath(ref)}/comments`, listOptions, (raw) => toComment(ref, raw));
+			}),
+			comment: perKind({
+				issue: true,
+				pull_request: true
+			}, async (thread, body, options) => {
+				const ref = requireIssueOrPull(thread, context, "comment on");
+				const { data } = await fetcher.json(`${issuePath(ref)}/comments`, {
+					method: "POST",
+					json: { body },
+					signal: options?.signal
+				});
+				return toComment(ref, data);
+			}),
+			editComment: perKind({
+				issue: true,
+				pull_request: true
+			}, async (ref, body, options) => {
+				const { data } = await fetcher.json(`${repoPath(ref.thread.repo)}/issues/comments/${encodeURIComponent(ref.id)}`, {
+					method: "PATCH",
+					json: { body },
+					signal: options?.signal
+				});
+				return toComment(ref.thread, data);
+			}),
+			deleteComment: perKind({
+				issue: true,
+				pull_request: true
+			}, async (ref, options) => {
+				await fetcher.raw(`${repoPath(ref.thread.repo)}/issues/comments/${encodeURIComponent(ref.id)}`, {
+					method: "DELETE",
+					signal: options?.signal
+				});
+			}),
+			create: perKind({
+				issue: true,
+				pull_request: true
+			}, async (repo, input, options) => {
+				const labels = input.labels?.length ? await resolveLabels(repo, input.labels) : void 0;
+				const assignees = input.assignees?.map(actorLogin);
+				if (input.kind === "issue") {
+					const { data } = await fetcher.json(`${repoPath(repo)}/issues`, {
+						method: "POST",
+						json: {
+							title: input.title,
+							body: input.body,
+							labels,
+							assignees
+						},
+						signal: options?.signal
+					});
+					return toThread({
+						...origin,
+						repo,
+						kind: "issue",
+						number: String(data.number)
+					}, 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)}/pulls`, {
+					method: "POST",
+					json: {
+						title: input.draft ? `WIP: ${input.title}` : input.title,
+						body: input.body,
+						head: input.head,
+						base: input.base,
+						labels,
+						assignees
+					},
+					signal: options?.signal
+				});
+				return toThread({
+					...origin,
+					repo,
+					kind: "pull_request",
+					number: String(data.number)
+				}, data);
+			}),
+			update: perKind({
+				issue: true,
+				pull_request: true
+			}, async (thread, input, options) => {
+				const ref = requireIssueOrPull(thread, context, "update");
+				const { data } = await fetcher.json(ref.kind === "pull_request" ? threadPath(ref) : issuePath(ref), {
+					method: "PATCH",
+					json: input,
+					signal: options?.signal
+				});
+				return toThread(ref, data);
+			}),
+			addLabels: perKind({
+				issue: true,
+				pull_request: true
+			}, async (thread, labels, options) => {
+				const ref = requireIssueOrPull(thread, context, "label");
+				await fetcher.raw(`${issuePath(ref)}/labels`, {
+					method: "POST",
+					json: { labels: await resolveLabels(ref.repo, labels) },
+					signal: options?.signal
+				});
+			}),
+			removeLabels: perKind({
+				issue: true,
+				pull_request: true
+			}, async (thread, labels, options) => {
+				const ref = requireIssueOrPull(thread, context, "label");
+				for (const id of await resolveLabels(ref.repo, labels)) await fetcher.raw(`${issuePath(ref)}/labels/${id}`, {
+					method: "DELETE",
+					signal: options?.signal
+				});
+			}),
+			setMilestone: perKind({
+				issue: true,
+				pull_request: true
+			}, async (thread, milestone, options) => {
+				const ref = requireIssueOrPull(thread, context, "set the milestone of");
+				await fetcher.raw(issuePath(ref), {
+					method: "PATCH",
+					json: { milestone: milestone === void 0 ? 0 : await milestoneId(milestone, (page) => milestonesPage(ref.repo, page), context, options) },
+					signal: options?.signal
+				});
+			}),
+			reactionsPage: perKind(ISSUE_AND_PULL, async (target, listOptions = {}) => {
+				const result = await fetcher.page(reactionPath(target), {
+					query: { limit: listOptions.perPage },
+					cursor: listOptions.cursor,
+					signal: listOptions.signal
+				});
+				return toPage(result, (raw) => {
+					const reactor = toActor(context, raw.user);
+					return reactor && {
+						content: reactionContent(raw.content),
+						contentRaw: raw.content,
+						actor: reactor,
+						createdAt: toDate(raw.created_at),
+						raw
+					};
+				});
+			}),
+			reactions: perKind({
+				issue: true,
+				pull_request: true
+			}, {
+				react: (target, reaction, options) => setReaction(target, reaction, "POST", options),
+				unreact: (target, reaction, options) => setReaction(target, reaction, "DELETE", options)
+			}),
+			setLabels: perKind({
+				issue: true,
+				pull_request: true
+			}, async (thread, labels, options) => {
+				const ref = requireIssueOrPull(thread, context, "label");
+				await fetcher.raw(`${issuePath(ref)}/labels`, {
+					method: "PUT",
+					json: { labels: await resolveLabels(ref.repo, labels) },
+					signal: options?.signal
+				});
+			}),
+			setAssignees: perKind({
+				issue: true,
+				pull_request: true
+			}, async (thread, assignees, options) => {
+				const ref = requireIssueOrPull(thread, context, "assign");
+				await fetcher.raw(issuePath(ref), {
+					method: "PATCH",
+					json: { assignees: assignees.map(actorLogin) },
+					signal: options?.signal
+				});
+			}),
+			requestReview: perKind({ pull_request: true }, async (thread, reviewers, options) => {
+				await fetcher.raw(`${threadPath(requireThread(thread, context))}/requested_reviewers`, {
+					method: "POST",
+					json: { reviewers: reviewers.map(actorLogin) },
+					signal: options?.signal
+				});
+			}),
+			close: perKind({
+				issue: true,
+				pull_request: true
+			}, (ref, options) => setState(ref, "closed", options)),
+			reopen: perKind({
+				issue: true,
+				pull_request: true
+			}, (ref, options) => setState(ref, "open", options)),
+			merge: verb(true, merge),
+			subscriptions: perKind(ISSUE_AND_PULL, {
+				async subscription(thread, options) {
+					const ref = requireIssueOrPull(thread, context, "read the subscription of");
+					const { data } = await fetcher.json(`${issuePath(ref)}/subscriptions/check`, { signal: options?.signal });
+					return data.ignored ? "ignored" : data.subscribed ? "subscribed" : "none";
+				},
+				async subscribe(thread, options) {
+					const ref = requireIssueOrPull(thread, context, "subscribe to");
+					await fetcher.raw(await subscriptionPath({
+						owner: ref.repo.owner,
+						name: ref.repo.name,
+						number: ref.number
+					}), {
+						method: "PUT",
+						signal: options?.signal
+					});
+				},
+				async unsubscribe(thread, options) {
+					const ref = requireIssueOrPull(thread, context, "unsubscribe from");
+					await fetcher.raw(await subscriptionPath({
+						owner: ref.repo.owner,
+						name: ref.repo.name,
+						number: ref.number
+					}), {
+						method: "DELETE",
+						signal: options?.signal
+					});
+				}
+			})
+		},
+		web: githubShapedWeb(baseUrl.replace(/\/api\/v1$/, ""), {
+			pull: "pulls",
+			commentFragment: "issuecomment-",
+			file: (at) => /^[0-9a-f]{40}$/.test(at) ? `/src/commit/${at}` : `/src/branch/${encodeURIComponent(at)}`,
+			lineFragment: (line) => `L${line}`,
+			reserved: FORGEJO_RESERVED_PATHS
+		}),
+		webhooks: {
+			listPage: verb(true, (target, listOptions = {}) => list(hooksPath(target), listOptions, (raw) => toWebhook(target, raw))),
+			create: verb(true, async (target, input, options) => toWebhook(target, (await fetcher.json(hooksPath(target), {
+				method: "POST",
+				json: {
+					type: "gitea",
+					active: input.active ?? true,
+					events: nativeEventsFor(FORGEJO_NATIVE_EVENTS, input.events, input.nativeEvents),
+					config: {
+						url: input.url,
+						content_type: input.contentType ?? "json",
+						...input.secret ? { secret: input.secret } : {}
+					}
+				},
+				signal: options?.signal
+			})).data)),
+			update: verb(true, async (ref, update, options) => toWebhook(ref.target, (await fetcher.json(`${hooksPath(ref.target)}/${encodeURIComponent(ref.id)}`, {
+				method: "PATCH",
+				json: {
+					...update.active === void 0 ? {} : { active: update.active },
+					...update.events || update.nativeEvents ? { events: nativeEventsFor(FORGEJO_NATIVE_EVENTS, update.events, update.nativeEvents) } : {},
+					...update.url || update.secret || update.contentType ? { config: {
+						...update.url ? { url: update.url } : {},
+						content_type: update.contentType ?? "json",
+						...update.secret ? { secret: update.secret } : {}
+					} } : {}
+				},
+				signal: options?.signal
+			})).data)),
+			delete: verb(true, async (ref, options) => {
+				await fetcher.raw(`${hooksPath(ref.target)}/${encodeURIComponent(ref.id)}`, {
+					method: "DELETE",
+					signal: options?.signal
+				});
+			}),
+			rotateSecret: verb(true, async (ref, secret, options) => {
+				const current = toWebhook(ref.target, (await fetcher.json(`${hooksPath(ref.target)}/${encodeURIComponent(ref.id)}`, { signal: options?.signal })).data);
+				const { data } = await fetcher.json(`${hooksPath(ref.target)}/${encodeURIComponent(ref.id)}`, {
+					method: "PATCH",
+					json: { config: {
+						url: current.url,
+						content_type: current.contentType ?? "json",
+						secret
+					} },
+					signal: options?.signal
+				});
+				return toWebhook(ref.target, data);
+			})
+		},
+		scopes: forgejoScopesFor
+	};
+}
+const FORGEJO = /* @__PURE__ */ forgejoDefinition(FORGEJO_PROFILE);
+/** Creates a Forgejo provider for Codeberg or any self-hosted Forgejo instance. */
+const forgejo = /* @__PURE__ */ defineForgeProvider({
+	...FORGEJO,
+	webhooks: forgejoWebhooks(FORGEJO_PROFILE)
+});
+/** `forgejo()` without webhook ingestion, for bundles that never receive a delivery. */
+const forgejoLite = /* @__PURE__ */ defineForgeProvider(FORGEJO);
+/**
+* Forgejo and Gitea token scopes, which are per resource group with a
+* `read:` or `write:` prefix.
+*/
+function forgejoScopesFor(verb) {
+	const [group = "", name = ""] = verb.split(".");
+	const write = (/* @__PURE__ */ new Set([
+		"comment",
+		"upsertComment",
+		"editComment",
+		"deleteComment",
+		"create",
+		"update",
+		"close",
+		"reopen",
+		"setLabels",
+		"addLabels",
+		"removeLabels",
+		"setMilestone",
+		"react",
+		"unreact",
+		"setAssignees",
+		"requestReview",
+		"merge",
+		"approveAndMerge",
+		"createReview",
+		"submitReview",
+		"approve",
+		"createLabel",
+		"addCollaborator",
+		"subscribe",
+		"unsubscribe",
+		"report"
+	])).has(name);
+	if (group === "webhooks") return name === "verify" || name === "ingest" ? {} : { token: ["write:repository", "write:organization"] };
+	if (group === "notifications") return { token: [name === "list" || name === "page" || name === "unreadCount" ? "read:notification" : "write:notification"] };
+	if (group === "users" || group === "search") return { token: ["read:user"] };
+	if (group === "threads" || group === "repos" || group === "contents" || group === "releases" || group === "checks" || group === "ci") return { token: [write ? "write:issue" : "read:issue", write ? "write:repository" : "read:repository"] };
+	return {};
+}
+//#endregion
+export { forgejoScopesFor as a, forgejoLite as i, forgejo as n, forgejoWebhooks as o, forgejoDefinition as r, GITEA_HEADERS as s, FORGEJO_PROFILE as t };