ryco-cli 0.1.30 → 0.1.31

package/dist/GitLabSourceControlProvider-DpWkJ0M3.mjs

@@ -0,0 +1,2258 @@
+#!/usr/bin/env node
+
+import { Ds as SourceControlProviderError, Gr as ChangeRequestReviewThread, Kr as ChangeRequestTimelineItem, Ts as SOURCE_CONTROL_WORKFLOW_LOG_MAX_BYTES, Ur as CHANGE_REQUEST_FILE_CONTENTS_MAX_BYTES, ks as truncateSourceControlDetailContent } from "./src-VTj60bUm.mjs";
+import { $r as withUnsupportedChangeRequestOptionGuards, Ar as isGitSha, Cr as CURRENT_GITLAB_PROJECT, Dr as gitLabWrite, Er as gitLabProjectEndpoint, Mr as parseGitLabMergeRequestReference, Nr as withGitLabQuery, Or as isGitLabDiscussionId, Qr as sourceControlRefFromInput, Sr as parseGitLabTimestamp, Tr as gitLabMergeRequestEndpoint, Xr as SourceControlProvider, Zr as sourceBranch, _r as gitLabMergeCapabilities, br as gitLabReviewDecision, cr as GitLabApprovalStateSchema, dr as GitLabReviewerSchema, fr as GitLabUserRefSchema, gr as gitLabDraftTitle, hr as gitLabAutoMerge, jr as isLastGitLabPage, kr as isGitLabNumericId, lr as GitLabMergeRequestDetailSchema, mr as gitLabAccessLevel, or as GitLabCli, pr as decodeGitLabMergeRequestListJson, rr as gitlabDiscovery, sr as GitLabCliError, ur as GitLabProjectSchema, vr as gitLabMergeRequestFacts, wr as gitLabGet, xr as gitLabReviewerStates, yr as gitLabMergeStateStatus } from "./bin.mjs";
+import { DateTime, Effect, Exit, Layer, Option, Result, Schema, SchemaIssue } from "effect";
+import { createHash } from "node:crypto";
+//#region src/sourceControl/gitLabMergeRequestDiffs.ts
+/**
+* GitLab file diffs (merge request `/diffs`, commit `/diff`) and the line
+* arithmetic GitLab positions need. Pure and side-effect free.
+*
+* Docs:
+* - https://docs.gitlab.com/api/merge_requests/#list-merge-request-diffs
+* - https://docs.gitlab.com/api/commits/#retrieve-commit-diff
+* - https://docs.gitlab.com/api/discussions/#create-a-new-thread-in-the-merge-request-diff
+*   (unchanged lines need both `old_line` and `new_line`; line codes are
+*   `<sha1(path)>_<old>_<new>`)
+*/
+const GitLabDiffEntrySchema = Schema.Struct({
+	old_path: Schema.String,
+	new_path: Schema.String,
+	a_mode: Schema.optional(Schema.NullOr(Schema.String)),
+	b_mode: Schema.optional(Schema.NullOr(Schema.String)),
+	diff: Schema.optional(Schema.NullOr(Schema.String)),
+	new_file: Schema.optional(Schema.NullOr(Schema.Boolean)),
+	renamed_file: Schema.optional(Schema.NullOr(Schema.Boolean)),
+	deleted_file: Schema.optional(Schema.NullOr(Schema.Boolean)),
+	collapsed: Schema.optional(Schema.NullOr(Schema.Boolean)),
+	too_large: Schema.optional(Schema.NullOr(Schema.Boolean))
+});
+/** GitLab's `DiffFile#file_path`: the new path, or the old one when there is none. */
+function gitLabDiffFilePath(entry) {
+	return entry.new_path || entry.old_path;
+}
+function findGitLabDiffEntry(entries, path) {
+	return entries.find((entry) => entry.new_path === path) ?? entries.find((entry) => entry.old_path === path);
+}
+/**
+* Rebuild a git-style unified diff from GitLab's per-file JSON. GitLab sends
+* only the hunks, so the `diff --git` / mode / rename / `---` `+++` headers are
+* restored here; a file without hunk text (binary, too large, pure rename or
+* mode change) keeps only its extended headers, as `git diff` prints them.
+*/
+function buildGitLabUnifiedDiff(entries) {
+	const out = [];
+	for (const entry of entries) {
+		const oldPath = entry.old_path || entry.new_path;
+		const newPath = entry.new_path || entry.old_path;
+		out.push(`diff --git a/${oldPath} b/${newPath}`);
+		if (entry.new_file === true) out.push(`new file mode ${entry.b_mode || "100644"}`);
+		else if (entry.deleted_file === true) out.push(`deleted file mode ${entry.a_mode || "100644"}`);
+		else if (entry.a_mode && entry.b_mode && entry.a_mode !== entry.b_mode) out.push(`old mode ${entry.a_mode}`, `new mode ${entry.b_mode}`);
+		if (entry.renamed_file === true && oldPath !== newPath) out.push(`rename from ${oldPath}`, `rename to ${newPath}`);
+		const body = entry.diff ?? "";
+		if (body.trim().length === 0) continue;
+		out.push(entry.new_file === true ? "--- /dev/null" : `--- a/${oldPath}`);
+		out.push(entry.deleted_file === true ? "+++ /dev/null" : `+++ b/${newPath}`);
+		out.push(body.endsWith("\n") ? body.slice(0, -1) : body);
+	}
+	return out.length === 0 ? "" : `${out.join("\n")}\n`;
+}
+const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/u;
+function parseGitLabDiffHunks(diff) {
+	const hunks = [];
+	const rows = diff.split("\n");
+	if (rows.at(-1) === "") rows.pop();
+	let current = null;
+	const flush = () => {
+		if (current) {
+			const { oldPos: _oldPos, newPos: _newPos, ...hunk } = current;
+			hunks.push(hunk);
+		}
+	};
+	for (const row of rows) {
+		const header = HUNK_HEADER.exec(row);
+		if (header) {
+			flush();
+			const oldStart = Number(header[1]);
+			const newStart = Number(header[3]);
+			current = {
+				header: row,
+				oldStart,
+				oldCount: header[2] === void 0 ? 1 : Number(header[2]),
+				newStart,
+				newCount: header[4] === void 0 ? 1 : Number(header[4]),
+				rawLines: [],
+				lines: [],
+				oldPos: oldStart,
+				newPos: newStart
+			};
+			continue;
+		}
+		if (!current) continue;
+		const rawIndex = current.rawLines.length;
+		current.rawLines.push(row);
+		const marker = row[0];
+		if (marker === "\\") continue;
+		if (marker === "+") {
+			current.lines.push({
+				kind: "added",
+				oldPos: current.oldPos,
+				newPos: current.newPos,
+				rawIndex
+			});
+			current.newPos += 1;
+		} else if (marker === "-") {
+			current.lines.push({
+				kind: "removed",
+				oldPos: current.oldPos,
+				newPos: current.newPos,
+				rawIndex
+			});
+			current.oldPos += 1;
+		} else {
+			current.lines.push({
+				kind: "context",
+				oldPos: current.oldPos,
+				newPos: current.newPos,
+				rawIndex
+			});
+			current.oldPos += 1;
+			current.newPos += 1;
+		}
+	}
+	flush();
+	return hunks;
+}
+function lineMatches(line, side, number) {
+	return side === "left" ? line.kind !== "added" && line.oldPos === number : line.kind !== "removed" && line.newPos === number;
+}
+function gitLabLineCode(filePath, oldPos, newPos) {
+	return `${createHash("sha1").update(filePath).digest("hex")}_${oldPos}_${newPos}`;
+}
+/**
+* Anchor `line` on `side` of a file's diff. Lines inside a hunk take their
+* hunk position; unchanged lines between hunks (expanded context) are
+* shifted by the hunks before them. Null when the line is not in the file.
+*/
+function resolveGitLabLineAnchor(entry, side, line) {
+	const filePath = gitLabDiffFilePath(entry);
+	const hunks = parseGitLabDiffHunks(entry.diff ?? "");
+	let delta = 0;
+	for (const hunk of hunks) {
+		const start = side === "left" ? hunk.oldStart : hunk.newStart;
+		const count = side === "left" ? hunk.oldCount : hunk.newCount;
+		const first = count === 0 ? start + 1 : start;
+		if (line < first) break;
+		if (line < first + count) {
+			const found = hunk.lines.find((candidate) => lineMatches(candidate, side, line));
+			return found ? {
+				kind: found.kind,
+				oldLine: found.kind === "added" ? null : found.oldPos,
+				newLine: found.kind === "removed" ? null : found.newPos,
+				lineCode: gitLabLineCode(filePath, found.oldPos, found.newPos)
+			} : null;
+		}
+		delta += hunk.newCount - hunk.oldCount;
+	}
+	if (entry.new_file === true || entry.deleted_file === true) return null;
+	const oldLine = side === "left" ? line : line - delta;
+	const newLine = side === "left" ? line + delta : line;
+	if (oldLine < 1 || newLine < 1) return null;
+	return {
+		kind: "context",
+		oldLine,
+		newLine,
+		lineCode: gitLabLineCode(filePath, oldLine, newLine)
+	};
+}
+/**
+* The hunk excerpt a thread was written against (as GitHub's `diffHunk`):
+* the hunk header and its lines up to and including the commented line.
+*/
+function gitLabDiffHunkExcerpt(entry, side, line) {
+	for (const hunk of parseGitLabDiffHunks(entry.diff ?? "")) {
+		const found = hunk.lines.find((candidate) => lineMatches(candidate, side, line));
+		if (found) return [hunk.header, ...hunk.rawLines.slice(0, found.rawIndex + 1)].join("\n");
+	}
+	return null;
+}
+function rangePoint(anchor) {
+	return {
+		line_code: anchor.lineCode,
+		type: anchor.kind === "added" ? "new" : "old",
+		...anchor.oldLine !== null ? { old_line: anchor.oldLine } : {},
+		...anchor.newLine !== null ? { new_line: anchor.newLine } : {}
+	};
+}
+/**
+* `POST .../draft_notes` body for one review comment, anchored to the diff
+* the reviewer saw (`diffRefs` must be the head they reviewed).
+* Docs: https://docs.gitlab.com/api/draft_notes/#create-a-draft-note
+*/
+function buildGitLabDraftNoteBody(input) {
+	const { comment, diffRefs } = input;
+	const entry = findGitLabDiffEntry(input.entries, comment.path);
+	if (!entry) return Result.fail(`${comment.path} is not part of this merge request's diff.`);
+	const shas = {
+		base_sha: diffRefs.base_sha,
+		start_sha: diffRefs.start_sha,
+		head_sha: diffRefs.head_sha,
+		old_path: entry.old_path,
+		new_path: entry.new_path
+	};
+	if (comment.subjectType === "file") return Result.succeed({
+		note: comment.body,
+		position: {
+			position_type: "file",
+			...shas
+		}
+	});
+	if (comment.line === void 0) return Result.fail(`The line comment on ${comment.path} is missing its line number.`);
+	const side = comment.side ?? "right";
+	const anchor = resolveGitLabLineAnchor(entry, side, comment.line);
+	if (!anchor) return Result.fail(`Line ${comment.line} of ${comment.path} is not part of this merge request's diff.`);
+	const startSide = comment.startSide ?? side;
+	const isRange = comment.startLine !== void 0 && (comment.startLine !== comment.line || startSide !== side);
+	let lineRange;
+	if (isRange && comment.startLine !== void 0) {
+		const start = resolveGitLabLineAnchor(entry, startSide, comment.startLine);
+		if (!start) return Result.fail(`Line ${comment.startLine} of ${comment.path} is not part of this merge request's diff.`);
+		lineRange = {
+			start: rangePoint(start),
+			end: rangePoint(anchor)
+		};
+	}
+	return Result.succeed({
+		note: comment.body,
+		position: {
+			position_type: "text",
+			...shas,
+			...anchor.oldLine !== null ? { old_line: anchor.oldLine } : {},
+			...anchor.newLine !== null ? { new_line: anchor.newLine } : {},
+			...lineRange ? { line_range: lineRange } : {}
+		}
+	});
+}
+/** Thread openers by one author this close together came from one published review. */
+const REVIEW_BATCH_WINDOW_MS = 6e4;
+const GitLabLineRangePointSchema = Schema.Struct({
+	line_code: Schema.optional(Schema.NullOr(Schema.String)),
+	type: Schema.optional(Schema.NullOr(Schema.String)),
+	old_line: Schema.optional(Schema.NullOr(Schema.Number)),
+	new_line: Schema.optional(Schema.NullOr(Schema.Number))
+});
+const GitLabPositionSchema = Schema.Struct({
+	base_sha: Schema.optional(Schema.NullOr(Schema.String)),
+	start_sha: Schema.optional(Schema.NullOr(Schema.String)),
+	head_sha: Schema.optional(Schema.NullOr(Schema.String)),
+	old_path: Schema.optional(Schema.NullOr(Schema.String)),
+	new_path: Schema.optional(Schema.NullOr(Schema.String)),
+	position_type: Schema.optional(Schema.NullOr(Schema.String)),
+	old_line: Schema.optional(Schema.NullOr(Schema.Number)),
+	new_line: Schema.optional(Schema.NullOr(Schema.Number)),
+	line_range: Schema.optional(Schema.NullOr(Schema.Struct({
+		start: Schema.optional(Schema.NullOr(GitLabLineRangePointSchema)),
+		end: Schema.optional(Schema.NullOr(GitLabLineRangePointSchema))
+	})))
+});
+const GitLabNoteSchema = Schema.Struct({
+	id: Schema.Number,
+	type: Schema.optional(Schema.NullOr(Schema.String)),
+	body: Schema.String,
+	author: Schema.optional(Schema.NullOr(GitLabUserRefSchema)),
+	created_at: Schema.String,
+	updated_at: Schema.optional(Schema.NullOr(Schema.String)),
+	system: Schema.optional(Schema.NullOr(Schema.Boolean)),
+	position: Schema.optional(Schema.NullOr(GitLabPositionSchema)),
+	resolvable: Schema.optional(Schema.NullOr(Schema.Boolean)),
+	resolved: Schema.optional(Schema.NullOr(Schema.Boolean)),
+	resolved_by: Schema.optional(Schema.NullOr(GitLabUserRefSchema)),
+	internal: Schema.optional(Schema.NullOr(Schema.Boolean))
+});
+const GitLabDiscussionSchema = Schema.Struct({
+	id: Schema.String,
+	individual_note: Schema.optional(Schema.NullOr(Schema.Boolean)),
+	resolvable: Schema.optional(Schema.NullOr(Schema.Boolean)),
+	resolved: Schema.optional(Schema.NullOr(Schema.Boolean)),
+	notes: Schema.Array(GitLabNoteSchema)
+});
+const GitLabStateEventSchema = Schema.Struct({
+	id: Schema.Number,
+	user: Schema.optional(Schema.NullOr(GitLabUserRefSchema)),
+	created_at: Schema.String,
+	state: Schema.String
+});
+const GitLabLabelEventSchema = Schema.Struct({
+	id: Schema.Number,
+	user: Schema.optional(Schema.NullOr(GitLabUserRefSchema)),
+	created_at: Schema.String,
+	action: Schema.String,
+	label: Schema.optional(Schema.NullOr(Schema.Struct({
+		name: Schema.String,
+		color: Schema.optional(Schema.NullOr(Schema.String)),
+		description: Schema.optional(Schema.NullOr(Schema.String))
+	})))
+});
+const GitLabCommitSchema = Schema.Struct({
+	id: Schema.String,
+	short_id: Schema.optional(Schema.NullOr(Schema.String)),
+	title: Schema.optional(Schema.NullOr(Schema.String)),
+	message: Schema.optional(Schema.NullOr(Schema.String)),
+	author_name: Schema.optional(Schema.NullOr(Schema.String)),
+	authored_date: Schema.optional(Schema.NullOr(Schema.String)),
+	committed_date: Schema.optional(Schema.NullOr(Schema.String)),
+	created_at: Schema.optional(Schema.NullOr(Schema.String))
+});
+const GitLabVersionSchema = Schema.Struct({
+	id: Schema.Number,
+	head_commit_sha: Schema.String,
+	base_commit_sha: Schema.optional(Schema.NullOr(Schema.String)),
+	start_commit_sha: Schema.optional(Schema.NullOr(Schema.String)),
+	created_at: Schema.String
+});
+const GitLabDraftNoteSchema = Schema.Struct({
+	id: Schema.Number,
+	author_id: Schema.optional(Schema.NullOr(Schema.Number)),
+	note: Schema.optional(Schema.NullOr(Schema.String))
+});
+const GitLabCurrentUserSchema = Schema.Struct({
+	id: Schema.Number,
+	username: Schema.String,
+	avatar_url: Schema.optional(Schema.NullOr(Schema.String)),
+	bot: Schema.optional(Schema.NullOr(Schema.Boolean))
+});
+const isTimelineItem = Schema.is(ChangeRequestTimelineItem);
+const isReviewThread = Schema.is(ChangeRequestReviewThread);
+function trimmed$1(value) {
+	const text = value?.trim() ?? "";
+	return text.length > 0 ? text : null;
+}
+function positiveInt(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+function gitLabActor(user) {
+	const login = trimmed$1(user?.username);
+	if (!login) return null;
+	const avatarUrl = trimmed$1(user?.avatar_url);
+	return {
+		login,
+		...avatarUrl ? { avatarUrl } : {},
+		...user?.bot === true ? { isBot: true } : {}
+	};
+}
+const HTML_ENTITIES = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'",
+	nbsp: " "
+};
+function decodeHtmlEntities(text) {
+	return text.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/giu, (match, entity) => {
+		if (entity.startsWith("#x") || entity.startsWith("#X")) return String.fromCodePoint(Number.parseInt(entity.slice(2), 16));
+		if (entity.startsWith("#")) return String.fromCodePoint(Number(entity.slice(1)));
+		return HTML_ENTITIES[entity.toLowerCase()] ?? match;
+	});
+}
+/** System notes are Markdown or (newer GitLab) HTML; compare them as plain text. */
+function gitLabSystemNoteText(body) {
+	return decodeHtmlEntities(body.replace(/<[^>]*>/gu, "")).replace(/\*\*/gu, "").replace(/\s+/gu, " ").trim();
+}
+/** Strip GitLab's inline-diff markers (`{-old-}`, `{+new+}`) from a title. */
+function stripInlineDiffMarkers(text) {
+	return text.replace(/\{[-+]|[-+]\}/gu, "");
+}
+/** The two titles of a "changed title from … to …" note, HTML or Markdown form. */
+function parseGitLabTitleChange(body) {
+	const html = [...body.matchAll(/<code[^>]*class="idiff"[^>]*>([\s\S]*?)<\/code>/giu)];
+	if (html.length >= 2 && html[0]?.[1] !== void 0 && html[1]?.[1] !== void 0) return {
+		previousTitle: decodeHtmlEntities(html[0][1].replace(/<[^>]*>/gu, "")).trim(),
+		currentTitle: decodeHtmlEntities(html[1][1].replace(/<[^>]*>/gu, "")).trim()
+	};
+	const markdown = /changed title from \*\*([\s\S]*)\*\* to \*\*([\s\S]*)\*\*\s*$/u.exec(body.trim());
+	if (markdown?.[1] !== void 0 && markdown[2] !== void 0) return {
+		previousTitle: stripInlineDiffMarkers(markdown[1]).trim(),
+		currentTitle: stripInlineDiffMarkers(markdown[2]).trim()
+	};
+	return null;
+}
+/** `@user` mentions in one clause of a system note. */
+function mentionedUsers(text) {
+	return [...text.matchAll(/@([\w.-]+)/gu)].flatMap((match) => match[1] ? [match[1].replace(/\.+$/u, "")] : []);
+}
+/** Split "requested review from @a and removed review request for @b" into its clauses. */
+function clauses(text, phrases) {
+	const lower = text.toLowerCase();
+	const found = phrases.flatMap((phrase) => {
+		const index = lower.indexOf(phrase);
+		return index >= 0 ? [{
+			phrase,
+			index
+		}] : [];
+	}).toSorted((left, right) => left.index - right.index);
+	return found.map((entry, position) => {
+		const end = found[position + 1]?.index ?? text.length;
+		return {
+			phrase: entry.phrase,
+			users: mentionedUsers(text.slice(entry.index + entry.phrase.length, end))
+		};
+	});
+}
+function projectWebUrl(mergeRequestUrl) {
+	const index = mergeRequestUrl.indexOf("/-/merge_requests/");
+	return index > 0 ? mergeRequestUrl.slice(0, index) : null;
+}
+function crossReference(text, mergeRequestUrl) {
+	const match = /^mentioned in (merge request|issue) ([\w./-]*?)([!#])(\d+)$/u.exec(text);
+	const number = match?.[4] ? positiveInt(Number(match[4])) : null;
+	const projectUrl = projectWebUrl(mergeRequestUrl);
+	if (!match || number === null || !projectUrl) return null;
+	const kind = match[1] === "merge request" ? "change-request" : "issue";
+	const repository = trimmed$1(match[2]);
+	return {
+		kind,
+		number,
+		url: `${repository ? `${new URL(projectUrl).origin}/${repository}` : projectUrl}/-/${kind === "change-request" ? "merge_requests" : "issues"}/${number}`,
+		...repository ? { repository } : {}
+	};
+}
+/**
+* One system note as timeline items. GitLab writes system notes as prose, so
+* only its documented, stable phrasings are recognised; anything else is
+* dropped rather than guessed at. State and label changes come from their
+* resource-event APIs, commits from the commit list, so their notes drop too.
+*/
+function gitLabSystemNoteItems(note, context) {
+	const createdAt = parseGitLabTimestamp(note.created_at);
+	if (!createdAt) return [];
+	const actor = gitLabActor(note.author);
+	const base = {
+		createdAt,
+		...actor ? { actor } : {}
+	};
+	const id = `note:${note.id}`;
+	const text = gitLabSystemNoteText(note.body);
+	const lower = text.toLowerCase();
+	if (lower.startsWith("changed title from")) {
+		const titles = parseGitLabTitleChange(note.body);
+		return titles ? [{
+			...base,
+			id,
+			kind: "renamed",
+			...titles
+		}] : [];
+	}
+	if (lower === "marked this merge request as draft" || lower === "marked as a work in progress" || lower === "marked this merge request as a draft") return [{
+		...base,
+		id,
+		kind: "converted-to-draft"
+	}];
+	if (lower === "marked this merge request as ready" || lower === "unmarked as a work in progress") return [{
+		...base,
+		id,
+		kind: "ready-for-review"
+	}];
+	if (lower.startsWith("requested review from") || lower.startsWith("removed review request for")) return clauses(text, ["requested review from", "removed review request for"]).flatMap((clause) => clause.users.map((reviewer) => ({
+		...base,
+		id: `${id}:${clause.phrase === "requested review from" ? "review-requested" : "review-request-removed"}:${reviewer}`,
+		kind: clause.phrase === "requested review from" ? "review-requested" : "review-request-removed",
+		reviewer,
+		reviewerKind: "user"
+	})));
+	if (lower.startsWith("assigned to") || lower.startsWith("unassigned")) return clauses(text, ["assigned to", "unassigned"]).flatMap((clause) => clause.users.map((assignee) => ({
+		...base,
+		id: `${id}:${clause.phrase === "assigned to" ? "assigned" : "unassigned"}:${assignee}`,
+		kind: clause.phrase === "assigned to" ? "assigned" : "unassigned",
+		assignee
+	})));
+	if (lower === "approved this merge request") return [{
+		...base,
+		id,
+		kind: "review",
+		state: "approved",
+		body: "",
+		threadIds: []
+	}];
+	if (lower === "requested changes") return [{
+		...base,
+		id,
+		kind: "review",
+		state: "changes_requested",
+		body: "",
+		threadIds: []
+	}];
+	if (lower === "unapproved this merge request" || lower.startsWith("revoked approval for this merge request")) return actor ? [{
+		...base,
+		id,
+		kind: "review-dismissed",
+		reviewAuthor: actor.login
+	}] : [];
+	if (lower.startsWith("reset approvals from")) {
+		const dismissed = [];
+		for (const reviewAuthor of mentionedUsers(text)) dismissed.push({
+			...base,
+			id: `${id}:review-dismissed:${reviewAuthor}`,
+			kind: "review-dismissed",
+			reviewAuthor,
+			message: "Approvals reset by a push to the branch."
+		});
+		return dismissed;
+	}
+	if (/^enabled (?:an )?automatic (?:merge|add to merge train)/u.test(lower)) return [{
+		...base,
+		id,
+		kind: "auto-merge-enabled"
+	}];
+	if (/^(?:canceled|cancelled|aborted) (?:the )?automatic (?:merge|add to merge train)/u.test(lower)) return [{
+		...base,
+		id,
+		kind: "auto-merge-disabled"
+	}];
+	const target = /^changed target branch from `?(.+?)`? to `?(.+?)`?$/u.exec(text);
+	if (target?.[1] && target[2]) return [{
+		...base,
+		id,
+		kind: "base-ref-changed",
+		previousRefName: target[1],
+		currentRefName: target[2]
+	}];
+	const reference = crossReference(text, context.mergeRequestUrl);
+	if (reference) return [{
+		...base,
+		id,
+		kind: "cross-referenced",
+		source: {
+			...reference,
+			title: ""
+		}
+	}];
+	return [];
+}
+/** Commits a push note ("added 2 commits … <li>abc123 - …") credits to its author. */
+function gitLabPushedCommitPrefixes(note) {
+	const text = gitLabSystemNoteText(note.body);
+	if (!/^added \d+ (?:new )?commits?/iu.test(text)) return [];
+	return [...note.body.matchAll(/<li>\s*([0-9a-f]{7,40})\s+-/giu)].flatMap((match) => match[1] ? [match[1].toLowerCase()] : []);
+}
+function noteComment(note, context) {
+	const createdAt = parseGitLabTimestamp(note.created_at);
+	if (!createdAt) return null;
+	const updatedAt = parseGitLabTimestamp(note.updated_at);
+	const own = context.viewerId !== null && note.author?.id === context.viewerId;
+	return {
+		id: String(note.id),
+		author: gitLabActor(note.author) ?? { login: "ghost" },
+		body: note.body,
+		createdAt,
+		...updatedAt && DateTime.toEpochMillis(updatedAt) !== DateTime.toEpochMillis(createdAt) ? { updatedAt } : {},
+		url: `${context.mergeRequestUrl}#note_${note.id}`,
+		state: "submitted",
+		viewerCanUpdate: own,
+		viewerCanDelete: own
+	};
+}
+function lineOf(point) {
+	const newLine = positiveInt(point.new_line);
+	if (newLine !== null) return {
+		side: "right",
+		line: newLine
+	};
+	const oldLine = positiveInt(point.old_line);
+	return oldLine !== null ? {
+		side: "left",
+		line: oldLine
+	} : null;
+}
+/**
+* A discussion with a diff position as a review thread. Positions follow the
+* merge request across pushes: GitLab moves a note's `position` to the new
+* head while its line still exists, so a position still on an older head no
+* longer maps onto the diff and the thread is outdated.
+*/
+function gitLabReviewThread(discussion, context) {
+	const notes = discussion.notes.filter((note) => note.system !== true);
+	const opener = notes[0];
+	const position = opener?.position;
+	if (!opener || !position) return null;
+	const positionType = position.position_type?.trim().toLowerCase() ?? "text";
+	if (positionType !== "text" && positionType !== "file") return null;
+	const path = trimmed$1(position.new_path) ?? trimmed$1(position.old_path);
+	const openerCreatedAt = parseGitLabTimestamp(opener.created_at);
+	if (!path || !openerCreatedAt) return null;
+	const positionHead = trimmed$1(position.head_sha);
+	const isOutdated = positionHead !== null && context.headSha !== null && positionHead !== context.headSha;
+	const anchor = positionType === "text" ? lineOf(position) : null;
+	if (positionType === "text" && !anchor) return null;
+	const side = anchor?.side ?? "right";
+	const rangeStart = position.line_range?.start ? lineOf(position.line_range.start) : null;
+	const start = anchor && rangeStart && (rangeStart.line !== anchor.line || rangeStart.side !== anchor.side) ? rangeStart : null;
+	const entry = !isOutdated && anchor && context.diffEntries ? findGitLabDiffEntry(context.diffEntries, path) : void 0;
+	const diffHunk = entry && anchor ? gitLabDiffHunkExcerpt(entry, anchor.side, anchor.line) : null;
+	const resolvable = notes.filter((note) => note.resolvable === true);
+	const isResolvable = resolvable.length > 0 || discussion.resolvable === true;
+	const isResolved = resolvable.length > 0 ? resolvable.every((note) => note.resolved === true) : discussion.resolved === true;
+	const resolvedBy = isResolved ? resolvable.map((note) => trimmed$1(note.resolved_by?.username)).findLast(Boolean) ?? null : null;
+	const comments = notes.slice(0, 100).flatMap((note) => {
+		const comment = noteComment(note, context);
+		return comment ? [comment] : [];
+	});
+	const thread = {
+		id: discussion.id,
+		path,
+		subjectType: positionType === "file" ? "file" : "line",
+		side,
+		...start ? { startSide: start.side } : {},
+		line: anchor && !isOutdated ? anchor.line : null,
+		...start ? { startLine: isOutdated ? null : start.line } : {},
+		...anchor ? { originalLine: anchor.line } : {},
+		...start ? { originalStartLine: start.line } : {},
+		...positionHead ? { originalCommitOid: positionHead } : {},
+		...diffHunk ? { diffHunk } : {},
+		isResolved,
+		isOutdated,
+		...resolvedBy ? { resolvedBy } : {},
+		viewerCanReply: context.viewerCanReply,
+		viewerCanResolve: isResolvable && !isResolved && context.viewerCanResolve,
+		viewerCanUnresolve: isResolvable && isResolved && context.viewerCanResolve,
+		comments,
+		totalComments: Math.max(notes.length, comments.length)
+	};
+	if (!isReviewThread(thread)) return null;
+	return {
+		thread,
+		openerAuthor: trimmed$1(opener.author?.username),
+		openerCreatedAt
+	};
+}
+function gitLabViewerCapabilities(input) {
+	const { user, facts } = input;
+	const login = trimmed$1(user?.username);
+	if (!user || !login) return null;
+	const access = gitLabAccessLevel(input.project);
+	const isAuthor = facts.authorId !== null ? facts.authorId === user.id : facts.authorUsername === login;
+	const canUpdate = isAuthor || access >= 30;
+	const canMerge = facts.canMerge === true;
+	return {
+		login,
+		isAuthor,
+		canUpdate,
+		canMerge,
+		canReview: !facts.discussionLocked || access > 0,
+		canUpdateBranch: canUpdate,
+		canEnableAutoMerge: canMerge,
+		canDisableAutoMerge: canMerge || facts.autoMergeBy !== null && facts.autoMergeBy === login
+	};
+}
+function epoch(value) {
+	return DateTime.toEpochMillis(value);
+}
+function commitItems(input, pushers) {
+	return input.commits.items.flatMap((commit) => {
+		const createdAt = parseGitLabTimestamp(commit.committed_date) ?? parseGitLabTimestamp(commit.created_at) ?? parseGitLabTimestamp(commit.authored_date);
+		const oid = trimmed$1(commit.id);
+		if (!createdAt || !oid) return [];
+		const [headline = "", ...rest] = (commit.message ?? commit.title ?? "").split("\n");
+		const body = rest.join("\n").trim();
+		const actor = [...pushers.entries()].find(([prefix]) => oid.toLowerCase().startsWith(prefix))?.[1];
+		return [{
+			id: `commit:${oid}`,
+			kind: "commit",
+			createdAt,
+			...actor ? { actor } : {},
+			oid,
+			shortOid: trimmed$1(commit.short_id) ?? oid.slice(0, 8),
+			messageHeadline: trimmed$1(commit.title) ?? headline.trim(),
+			...body ? { messageBody: body } : {}
+		}];
+	});
+}
+/**
+* A push that rewrote history: the previous version's head is no longer one
+* of the merge request's commits. Undecidable when the commit list is cut.
+*/
+function forcePushItems(input) {
+	if (input.commits.truncated) return [];
+	const known = new Set(input.commits.items.map((commit) => commit.id.toLowerCase()));
+	const versions = input.versions.flatMap((version) => {
+		const createdAt = parseGitLabTimestamp(version.created_at);
+		return createdAt ? [{
+			version,
+			createdAt
+		}] : [];
+	}).toSorted((left, right) => epoch(left.createdAt) - epoch(right.createdAt));
+	const items = [];
+	for (let index = 1; index < versions.length; index += 1) {
+		const previous = versions[index - 1];
+		const current = versions[index];
+		if (!previous || !current) continue;
+		const before = previous.version.head_commit_sha.trim();
+		const after = current.version.head_commit_sha.trim();
+		if (!before || !after || before === after || known.has(before.toLowerCase())) continue;
+		items.push({
+			id: `version:${current.version.id}`,
+			kind: "force-pushed",
+			createdAt: current.createdAt,
+			beforeOid: before,
+			afterOid: after
+		});
+	}
+	return items;
+}
+function eventItems(input) {
+	const items = [];
+	for (const event of input.stateEvents) {
+		const createdAt = parseGitLabTimestamp(event.created_at);
+		if (!createdAt) continue;
+		const actor = gitLabActor(event.user);
+		const base = {
+			id: `state:${event.id}`,
+			createdAt,
+			...actor ? { actor } : {}
+		};
+		switch (event.state.trim().toLowerCase()) {
+			case "merged":
+				items.push({
+					...base,
+					kind: "merged",
+					...input.facts.mergeCommitSha ? { commitOid: input.facts.mergeCommitSha } : {},
+					baseRefName: input.facts.targetBranch
+				});
+				break;
+			case "closed":
+				items.push({
+					...base,
+					kind: "closed"
+				});
+				break;
+			case "reopened": items.push({
+				...base,
+				kind: "reopened"
+			});
+		}
+	}
+	for (const event of input.labelEvents) {
+		const createdAt = parseGitLabTimestamp(event.created_at);
+		const name = trimmed$1(event.label?.name);
+		const action = event.action.trim().toLowerCase();
+		if (!createdAt || !name || action !== "add" && action !== "remove") continue;
+		const actor = gitLabActor(event.user);
+		const color = trimmed$1(event.label?.color)?.replace(/^#/u, "").toLowerCase();
+		const description = trimmed$1(event.label?.description);
+		items.push({
+			id: `label:${event.id}`,
+			kind: action === "add" ? "labeled" : "unlabeled",
+			createdAt,
+			...actor ? { actor } : {},
+			label: {
+				name,
+				...color && /^[0-9a-f]{3,8}$/u.test(color) ? { color } : {},
+				...description ? { description } : {}
+			}
+		});
+	}
+	return items;
+}
+/** Threads published together (one author, openers within a minute) form one review. */
+function reviewItems(entries) {
+	const sorted = entries.toSorted((left, right) => epoch(left.openerCreatedAt) - epoch(right.openerCreatedAt));
+	const items = [];
+	let batch = [];
+	const flush = () => {
+		const first = batch[0];
+		if (!first) return;
+		const actor = first.thread.comments[0]?.author;
+		items.push({
+			id: `review:${first.thread.id}`,
+			kind: "review",
+			createdAt: first.openerCreatedAt,
+			...actor ? { actor } : {},
+			state: "commented",
+			body: "",
+			threadIds: batch.map((entry) => entry.thread.id)
+		});
+		batch = [];
+	};
+	for (const entry of sorted) {
+		const last = batch.at(-1);
+		if (last && (last.openerAuthor !== entry.openerAuthor || epoch(entry.openerCreatedAt) - epoch(last.openerCreatedAt) > REVIEW_BATCH_WINDOW_MS)) flush();
+		batch.push(entry);
+	}
+	flush();
+	return items;
+}
+function assembleGitLabChangeRequestActivity(input) {
+	const { facts } = input;
+	const viewer = gitLabViewerCapabilities(input);
+	const access = gitLabAccessLevel(input.project);
+	const threadContext = {
+		mergeRequestUrl: facts.webUrl,
+		headSha: facts.headSha,
+		viewerId: input.user?.id ?? null,
+		viewerCanReply: viewer !== null && viewer.canReview,
+		viewerCanResolve: viewer !== null && (viewer.isAuthor || access >= 30),
+		diffEntries: input.diffEntries
+	};
+	const threadEntries = input.discussions.items.flatMap((discussion) => {
+		const entry = gitLabReviewThread(discussion, threadContext);
+		return entry ? [entry] : [];
+	});
+	const threadIds = new Set(threadEntries.map((entry) => entry.thread.id));
+	const pushers = /* @__PURE__ */ new Map();
+	const timeline = [];
+	const seen = /* @__PURE__ */ new Set();
+	const push = (item) => {
+		if (seen.has(item.id) || !isTimelineItem(item)) return;
+		seen.add(item.id);
+		timeline.push(item);
+	};
+	const notes = input.notes.items.toSorted((left, right) => Date.parse(left.created_at) - Date.parse(right.created_at) || left.id - right.id);
+	for (const note of notes) {
+		if (note.system === true) {
+			const actor = gitLabActor(note.author);
+			if (actor) for (const prefix of gitLabPushedCommitPrefixes(note)) pushers.set(prefix, actor);
+			for (const item of gitLabSystemNoteItems(note, {
+				mergeRequestUrl: facts.webUrl,
+				targetBranch: facts.targetBranch
+			})) push(item);
+			continue;
+		}
+		if (note.position || note.type === "DiffNote") continue;
+		const comment = noteComment(note, {
+			...threadContext,
+			diffEntries: null
+		});
+		if (!comment) continue;
+		push({
+			id: `note:${note.id}`,
+			kind: "comment",
+			createdAt: comment.createdAt,
+			actor: comment.author,
+			body: comment.body,
+			...comment.updatedAt ? { updatedAt: comment.updatedAt } : {},
+			...comment.url ? { url: comment.url } : {},
+			viewerCanUpdate: comment.viewerCanUpdate === true,
+			viewerCanDelete: comment.viewerCanDelete === true
+		});
+	}
+	const cutoff = input.notes.truncated && notes[0] ? Date.parse(notes[0].created_at) : null;
+	for (const item of [
+		...eventItems(input),
+		...commitItems(input, pushers),
+		...forcePushItems(input),
+		...reviewItems(threadEntries.filter((entry) => threadIds.has(entry.thread.id)))
+	]) {
+		if (cutoff !== null && epoch(item.createdAt) < cutoff) continue;
+		push(item);
+	}
+	timeline.sort((left, right) => epoch(left.createdAt) - epoch(right.createdAt));
+	return {
+		provider: "gitlab",
+		number: facts.iid,
+		headSha: facts.headSha,
+		viewer,
+		timeline,
+		timelineTruncated: input.notes.truncated || input.commits.truncated,
+		reviewThreads: threadEntries.map((entry) => entry.thread),
+		reviewThreadsTruncated: input.discussions.truncated,
+		pendingReview: input.draftNotes && input.draftNotes.length > 0 ? {
+			id: "draft-notes",
+			commentsCount: input.draftNotes.length
+		} : null
+	};
+}
+//#endregion
+//#region src/sourceControl/gitLabPipelines.ts
+/**
+* GitLab CI as the page's checks: pipelines are workflow runs, jobs are jobs
+* (GitLab jobs have no steps), commit statuses are the check rollup. Pure.
+*
+* Docs:
+* - https://docs.gitlab.com/api/merge_requests/#list-merge-request-pipelines
+* - https://docs.gitlab.com/api/pipelines/#list-project-pipelines
+* - https://docs.gitlab.com/api/jobs/#list-all-jobs-by-pipeline
+* - https://docs.gitlab.com/api/jobs/#retrieve-a-log-file-for-a-job
+* - https://docs.gitlab.com/api/commits/#list-commit-statuses
+*/
+const GitLabPipelineSchema = Schema.Struct({
+	id: Schema.Number,
+	iid: Schema.optional(Schema.NullOr(Schema.Number)),
+	sha: Schema.String,
+	ref: Schema.optional(Schema.NullOr(Schema.String)),
+	status: Schema.String,
+	source: Schema.optional(Schema.NullOr(Schema.String)),
+	name: Schema.optional(Schema.NullOr(Schema.String)),
+	web_url: Schema.optional(Schema.NullOr(Schema.String)),
+	created_at: Schema.optional(Schema.NullOr(Schema.String)),
+	updated_at: Schema.optional(Schema.NullOr(Schema.String)),
+	started_at: Schema.optional(Schema.NullOr(Schema.String)),
+	finished_at: Schema.optional(Schema.NullOr(Schema.String)),
+	duration: Schema.optional(Schema.NullOr(Schema.Number)),
+	user: Schema.optional(Schema.NullOr(GitLabUserRefSchema))
+});
+const GitLabJobSchema = Schema.Struct({
+	id: Schema.Number,
+	name: Schema.String,
+	stage: Schema.optional(Schema.NullOr(Schema.String)),
+	status: Schema.String,
+	allow_failure: Schema.optional(Schema.NullOr(Schema.Boolean)),
+	started_at: Schema.optional(Schema.NullOr(Schema.String)),
+	finished_at: Schema.optional(Schema.NullOr(Schema.String)),
+	duration: Schema.optional(Schema.NullOr(Schema.Number)),
+	web_url: Schema.optional(Schema.NullOr(Schema.String))
+});
+const GitLabCommitStatusSchema = Schema.Struct({
+	id: Schema.Number,
+	/** GitLab 17.9+. */
+	pipeline_id: Schema.optional(Schema.NullOr(Schema.Number)),
+	name: Schema.String,
+	status: Schema.String,
+	target_url: Schema.optional(Schema.NullOr(Schema.String)),
+	allow_failure: Schema.optional(Schema.NullOr(Schema.Boolean)),
+	created_at: Schema.optional(Schema.NullOr(Schema.String)),
+	started_at: Schema.optional(Schema.NullOr(Schema.String)),
+	finished_at: Schema.optional(Schema.NullOr(Schema.String))
+});
+function trimmed(value) {
+	const text = value?.trim() ?? "";
+	return text.length > 0 ? text : null;
+}
+function optionString(value) {
+	const text = trimmed(value);
+	return text ? Option.some(text) : Option.none();
+}
+function optionTime(value) {
+	const parsed = parseGitLabTimestamp(value);
+	return parsed ? Option.some(parsed) : Option.none();
+}
+function durationMs(seconds) {
+	return typeof seconds === "number" && Number.isFinite(seconds) && seconds >= 0 ? Option.some(Math.round(seconds * 1e3)) : Option.none();
+}
+/**
+* GitLab pipeline/job/status values as the GitHub-style status + conclusion
+* the page classifies. A failure GitLab tolerates (`allow_failure`) is
+* neutral, an optional manual job is skipped, a blocking one waits.
+*/
+function gitLabCheckState(status, allowFailure = false) {
+	switch (status.trim().toLowerCase()) {
+		case "success": return {
+			status: "completed",
+			conclusion: "success"
+		};
+		case "failed": return {
+			status: "completed",
+			conclusion: allowFailure ? "neutral" : "failure"
+		};
+		case "canceled":
+		case "cancelled": return {
+			status: "completed",
+			conclusion: "cancelled"
+		};
+		case "skipped": return {
+			status: "completed",
+			conclusion: "skipped"
+		};
+		case "manual": return allowFailure ? {
+			status: "completed",
+			conclusion: "skipped"
+		} : {
+			status: "waiting",
+			conclusion: null
+		};
+		case "running":
+		case "canceling": return {
+			status: "in_progress",
+			conclusion: null
+		};
+		case "created":
+		case "pending":
+		case "preparing":
+		case "scheduled":
+		case "waiting_for_resource":
+		case "waiting_for_callback": return {
+			status: "queued",
+			conclusion: null
+		};
+		default: return {
+			status: status.trim().toLowerCase() || "unknown",
+			conclusion: null
+		};
+	}
+}
+/**
+* A pipeline's name on the page: its `name` (`workflow:name`), else
+* `Pipeline #<iid>`. The runs list and the check rollup both use it, so the
+* rollup's jobs group under their pipeline.
+*/
+function gitLabPipelineRunName(pipeline) {
+	return trimmed(pipeline.name) ?? `Pipeline #${pipeline.iid ?? pipeline.id}`;
+}
+/**
+* @param sourceHeadOid The merge request head the pipeline verifies when it
+*   ran on a merged-results or merge-train commit (see `sourceHeadOid`).
+*/
+function gitLabWorkflowRun(pipeline, sourceHeadOid) {
+	const sha = trimmed(pipeline.sha);
+	const url = trimmed(pipeline.web_url);
+	if (!sha || !url) return null;
+	const state = gitLabCheckState(pipeline.status);
+	const event = trimmed(pipeline.source);
+	const source = trimmed(sourceHeadOid);
+	return {
+		provider: "gitlab",
+		runId: String(pipeline.id),
+		workflowName: gitLabPipelineRunName(pipeline),
+		branch: optionString(pipeline.ref),
+		...event ? { event } : {},
+		commit: {
+			oid: sha,
+			shortOid: sha.slice(0, 8)
+		},
+		...source && source !== sha ? { sourceHeadOid: source } : {},
+		actor: optionString(pipeline.user?.username),
+		status: state.status,
+		conclusion: optionString(state.conclusion),
+		startedAt: optionTime(pipeline.started_at ?? pipeline.created_at),
+		updatedAt: optionTime(pipeline.updated_at ?? pipeline.finished_at),
+		durationMs: durationMs(pipeline.duration),
+		url
+	};
+}
+/**
+* The merge request's pipelines for its current head: those on the head
+* commit plus the head pipeline itself, whose SHA is the merged-results or
+* merge-train commit rather than the head.
+*/
+function selectGitLabHeadPipelines(pipelines, head) {
+	return pipelines.filter((pipeline) => head.headSha !== null && pipeline.sha === head.headSha || head.headPipelineId !== null && pipeline.id === head.headPipelineId);
+}
+function gitLabWorkflowJob(job) {
+	const state = gitLabCheckState(job.status, job.allow_failure === true);
+	const stage = trimmed(job.stage);
+	const name = trimmed(job.name) ?? `Job ${job.id}`;
+	return {
+		jobId: String(job.id),
+		name: stage ? `${stage} / ${name}` : name,
+		status: state.status,
+		conclusion: optionString(state.conclusion),
+		startedAt: optionTime(job.started_at),
+		completedAt: optionTime(job.finished_at),
+		durationMs: durationMs(job.duration),
+		url: optionString(job.web_url),
+		steps: []
+	};
+}
+/**
+* The newest status per name (retries replace earlier attempts). GitLab lists
+* every CI job as a commit status too (a job is a `CommitStatus` row with the
+* same id), so the head pipeline's jobs become check runs of that pipeline,
+* named and linked as its jobs list names them; only what is left (external
+* statuses, trigger jobs, other pipelines) stays a status context. Without the
+* head pipeline's jobs, every status is a status context.
+*/
+function gitLabCheckRollup(statuses, headPipeline) {
+	const latest = /* @__PURE__ */ new Map();
+	for (const status of statuses) {
+		const name = trimmed(status.name);
+		if (!name) continue;
+		const existing = latest.get(name);
+		if (!existing || existing.id < status.id) latest.set(name, status);
+	}
+	const jobsById = new Map((headPipeline?.jobs ?? []).map((job) => [job.id, job]));
+	return [...latest.values()].toSorted((left, right) => left.id - right.id).map((status) => {
+		const state = gitLabCheckState(status.status, status.allow_failure === true);
+		const job = jobsById.get(status.id);
+		const statusUrl = optionString(status.target_url);
+		const startedAt = optionTime(status.started_at ?? status.created_at);
+		const completedAt = optionTime(status.finished_at);
+		if (job && headPipeline) {
+			const mapped = gitLabWorkflowJob(job);
+			return {
+				kind: "check-run",
+				name: mapped.name,
+				workflowName: headPipeline.runName,
+				status: Option.some(state.status),
+				conclusion: optionString(state.conclusion),
+				url: Option.orElse(mapped.url, () => statusUrl),
+				startedAt,
+				completedAt
+			};
+		}
+		return {
+			kind: "status-context",
+			name: status.name.trim(),
+			status: Option.some(state.status),
+			conclusion: optionString(state.conclusion),
+			url: statusUrl,
+			startedAt,
+			completedAt
+		};
+	});
+}
+/**
+* A list row's pipeline as a one-item rollup: the newest pipeline on the
+* merge request's refs (`refs/merge-requests/<iid>/…`) or its branch head.
+*/
+function gitLabListRowRollup(pipelines, row) {
+	const mergeRequestRef = `refs/merge-requests/${row.iid}/`;
+	const pipeline = pipelines.filter((candidate) => candidate.ref?.startsWith(mergeRequestRef) === true || candidate.ref === row.sourceBranch && row.headSha !== null && candidate.sha === row.headSha).toSorted((left, right) => right.id - left.id)[0];
+	if (!pipeline) return null;
+	const state = gitLabCheckState(pipeline.status);
+	return [{
+		kind: "unknown",
+		name: trimmed(pipeline.name) ?? "Pipeline",
+		status: Option.some(state.status),
+		conclusion: optionString(state.conclusion),
+		url: optionString(pipeline.web_url),
+		startedAt: optionTime(pipeline.started_at ?? pipeline.created_at),
+		completedAt: optionTime(pipeline.finished_at)
+	}];
+}
+const SECTION_MARKER = /section_(?:start|end):\d+:[^\r\n\u001b]*(?:\r?\u001b\[0K)?/gu;
+const ANSI_ESCAPE = /\u001b\[[0-9;?]*[A-Za-z]/gu;
+/**
+* Plain text, newest output kept: the end of a log is where a job failed.
+* `startCut`: the raw log is already only its tail, so its first line may
+* begin inside a section marker or escape and is dropped.
+*/
+function gitLabJobLogTail(raw, options) {
+	const startCut = options?.startCut === true;
+	const newline = startCut ? raw.indexOf("\n") : -1;
+	const plain = (startCut ? newline >= 0 ? raw.slice(newline + 1) : "" : raw).replace(SECTION_MARKER, "").replace(ANSI_ESCAPE, "").replace(/\r\n/gu, "\n");
+	const bytes = Buffer.from(plain, "utf8");
+	if (bytes.byteLength <= 204800) return {
+		log: plain,
+		truncated: startCut
+	};
+	let tail = bytes.subarray(bytes.byteLength - SOURCE_CONTROL_WORKFLOW_LOG_MAX_BYTES);
+	let offset = 0;
+	while (offset < tail.length && ((tail[offset] ?? 0) & 192) === 128) offset += 1;
+	tail = tail.subarray(offset);
+	return {
+		log: tail.toString("utf8"),
+		truncated: true
+	};
+}
+//#endregion
+//#region src/sourceControl/gitLabMergeRequestPage.ts
+/** List pages can carry long bodies; the process default (1 MB) is too small. */
+const LIST_PAGE_MAX_BYTES = 16777216;
+const DIFF_PAGE_MAX_BYTES = 33554432;
+const DIFF_TIMEOUT_MS = 6e4;
+/** Files read for a whole merge request diff (100 per page). */
+const DIFF_MAX_PAGES = 30;
+/** Files read to anchor review comments / excerpt thread hunks. */
+const ACTIVITY_DIFF_MAX_PAGES = 3;
+const COMMIT_PAGES = 3;
+/**
+* Raw bytes kept from the end of a job log: room for the shown tail
+* (`SOURCE_CONTROL_WORKFLOW_LOG_MAX_BYTES`) once colours and section markers
+* are stripped. Longer logs stream through and only their end is kept.
+*/
+const JOB_LOG_TAIL_BYTES = 8 * SOURCE_CONTROL_WORKFLOW_LOG_MAX_BYTES;
+/** First GitLab release whose `bulk_publish` records `reviewer_state` (verify). */
+const REQUEST_CHANGES_MIN_VERSION = {
+	major: 19,
+	minor: 2
+};
+function fail(operation, detail, status) {
+	return new GitLabCliError({
+		operation,
+		detail,
+		...status !== void 0 ? { status } : {}
+	});
+}
+function gitLabStaleHeadError(operation) {
+	return fail(operation, "The merge request's head changed since it was loaded. Refresh and review the new commits, then try again.", 409);
+}
+function isStatus(status) {
+	return (error) => error.status === status;
+}
+function requireGitLabMergeRequestRef(operation, reference) {
+	const ref = parseGitLabMergeRequestReference(reference);
+	return ref ? Effect.succeed(ref) : Effect.fail(fail(operation, `"${reference}" is not a merge request number or merge request URL.`));
+}
+function decodeJson(operation, schema, raw) {
+	return Schema.decodeEffect(Schema.fromJsonString(schema))(raw.trim()).pipe(Effect.mapError((error) => fail(operation, `GitLab returned an unexpected response: ${SchemaIssue.makeFormatterDefault()(error.issue)}`)));
+}
+const decodeUnknownArray = Schema.fromJsonString(Schema.Array(Schema.Unknown));
+/** A JSON array, keeping the entries `item` decodes (one odd entry must not hide the rest). */
+function decodeList(operation, item, raw) {
+	const decodeItem = Schema.decodeUnknownExit(item);
+	return Schema.decodeEffect(decodeUnknownArray)(raw.trim() || "[]").pipe(Effect.mapError((error) => fail(operation, `GitLab returned an unexpected list: ${SchemaIssue.makeFormatterDefault()(error.issue)}`)), Effect.map((entries) => entries.flatMap((entry) => {
+		const decoded = decodeItem(entry);
+		return Exit.isSuccess(decoded) ? [decoded.value] : [];
+	})));
+}
+function getJson(call, operation, request, schema) {
+	return call(operation, request, { maxOutputBytes: LIST_PAGE_MAX_BYTES }).pipe(Effect.flatMap((output) => decodeJson(operation, schema, output.stdout)));
+}
+/**
+* Read up to `maxPages` pages of a list endpoint. A short page ends the
+* list; a full last page means more exist (`truncated`).
+*/
+function getGitLabPages(call, operation, input) {
+	const perPage = input.perPage ?? 100;
+	return Effect.gen(function* () {
+		const items = [];
+		for (let page = 1; page <= input.maxPages; page += 1) {
+			const raw = (yield* call(operation, gitLabGet(input.ref, withGitLabQuery(input.endpoint, {
+				per_page: perPage,
+				page
+			})), {
+				maxOutputBytes: input.maxOutputBytes ?? LIST_PAGE_MAX_BYTES,
+				...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {}
+			})).stdout.trim() || "[]";
+			const count = yield* Schema.decodeEffect(decodeUnknownArray)(raw).pipe(Effect.map((entries) => entries.length), Effect.mapError(() => fail(operation, "GitLab returned an unexpected list.")));
+			items.push(...yield* decodeList(operation, input.item, raw));
+			if (isLastGitLabPage(count, perPage)) return {
+				items,
+				truncated: false
+			};
+		}
+		return {
+			items,
+			truncated: true
+		};
+	});
+}
+function getGitLabMergeRequestFacts(call, operation, ref) {
+	return getJson(call, operation, gitLabGet(ref, gitLabMergeRequestEndpoint(ref)), GitLabMergeRequestDetailSchema).pipe(Effect.map(gitLabMergeRequestFacts));
+}
+function getCurrentUser(call, operation, ref) {
+	return getJson(call, operation, gitLabGet(ref, "user"), GitLabCurrentUserSchema);
+}
+function getProject(call, operation, ref) {
+	return getJson(call, operation, gitLabGet(ref, gitLabProjectEndpoint(ref)), GitLabProjectSchema);
+}
+/** A best-effort read: a failure is logged and reads as `fallback`. */
+function optional(effect, fallback) {
+	return effect.pipe(Effect.catch((error) => Effect.logWarning("GitLab read failed; continuing without it.", {
+		operation: error.operation,
+		detail: error.detail
+	}).pipe(Effect.as(fallback))));
+}
+function getDiffEntries(call, operation, ref, maxPages) {
+	return getGitLabPages(call, operation, {
+		ref,
+		endpoint: gitLabMergeRequestEndpoint(ref, "/diffs"),
+		item: GitLabDiffEntrySchema,
+		maxPages,
+		maxOutputBytes: DIFF_PAGE_MAX_BYTES,
+		timeoutMs: DIFF_TIMEOUT_MS
+	});
+}
+function hasActiveLineThread(discussions, headSha) {
+	return discussions.some((discussion) => {
+		const position = discussion.notes.find((note) => note.system !== true)?.position;
+		return position?.position_type !== "file" && position !== void 0 && position !== null && (headSha === null || position.head_sha === headSha);
+	});
+}
+function fetchGitLabChangeRequestActivity(call, reference) {
+	const operation = "getChangeRequestActivity";
+	return Effect.gen(function* () {
+		const ref = yield* requireGitLabMergeRequestRef(operation, reference);
+		const pages = (suffix, item, maxPages) => getGitLabPages(call, operation, {
+			ref,
+			endpoint: gitLabMergeRequestEndpoint(ref, suffix),
+			item,
+			maxPages
+		});
+		const read = yield* Effect.all({
+			facts: getGitLabMergeRequestFacts(call, operation, ref),
+			user: optional(getCurrentUser(call, operation, ref), null),
+			project: optional(getProject(call, operation, ref), null),
+			notes: pages(withGitLabQuery("/notes", {
+				sort: "desc",
+				order_by: "created_at"
+			}), GitLabNoteSchema, 3),
+			discussions: pages("/discussions", GitLabDiscussionSchema, 3),
+			stateEvents: optional(pages("/resource_state_events", GitLabStateEventSchema, 1), {
+				items: [],
+				truncated: false
+			}),
+			labelEvents: optional(pages("/resource_label_events", GitLabLabelEventSchema, 1), {
+				items: [],
+				truncated: false
+			}),
+			commits: optional(pages("/commits", GitLabCommitSchema, 1), {
+				items: [],
+				truncated: false
+			}),
+			versions: optional(pages("/versions", GitLabVersionSchema, 1), {
+				items: [],
+				truncated: false
+			}),
+			draftNotes: optional(pages("/draft_notes", GitLabDraftNoteSchema, 1).pipe(Effect.map((page) => page.items)), null)
+		}, { concurrency: 6 });
+		const diffEntries = hasActiveLineThread(read.discussions.items, read.facts.headSha) ? yield* optional(getDiffEntries(call, operation, ref, ACTIVITY_DIFF_MAX_PAGES).pipe(Effect.map((page) => page.items)), null) : null;
+		return assembleGitLabChangeRequestActivity({
+			facts: read.facts,
+			user: read.user,
+			project: read.project,
+			notes: read.notes,
+			discussions: read.discussions,
+			stateEvents: read.stateEvents.items,
+			labelEvents: read.labelEvents.items,
+			commits: read.commits,
+			versions: read.versions.items,
+			draftNotes: read.draftNotes,
+			diffEntries
+		});
+	});
+}
+/** One discussion re-read as a review thread (after a reply). */
+function fetchGitLabReviewThread(call, operation, ref, discussionId) {
+	return Effect.gen(function* () {
+		const read = yield* Effect.all({
+			discussion: getJson(call, operation, gitLabGet(ref, gitLabMergeRequestEndpoint(ref, `/discussions/${discussionId}`)), GitLabDiscussionSchema),
+			facts: getGitLabMergeRequestFacts(call, operation, ref),
+			user: optional(getCurrentUser(call, operation, ref), null),
+			project: optional(getProject(call, operation, ref), null)
+		}, { concurrency: 4 });
+		const diffEntries = hasActiveLineThread([read.discussion], read.facts.headSha) ? yield* optional(getDiffEntries(call, operation, ref, ACTIVITY_DIFF_MAX_PAGES).pipe(Effect.map((page) => page.items)), null) : null;
+		const viewer = gitLabViewerCapabilities(read);
+		const entry = gitLabReviewThread(read.discussion, {
+			mergeRequestUrl: read.facts.webUrl,
+			headSha: read.facts.headSha,
+			viewerId: read.user?.id ?? null,
+			viewerCanReply: viewer !== null && viewer.canReview,
+			viewerCanResolve: viewer !== null && (viewer.isAuthor || gitLabAccessLevel(read.project) >= 30),
+			diffEntries
+		});
+		if (!entry) return yield* fail(operation, "This discussion is not a review thread on the diff.");
+		return entry.thread;
+	});
+}
+/** The merge request's commit SHAs (newest first), bounded. */
+function listCommitShas(call, operation, ref) {
+	return getGitLabPages(call, operation, {
+		ref,
+		endpoint: gitLabMergeRequestEndpoint(ref, "/commits"),
+		item: GitLabCommitSchema,
+		maxPages: COMMIT_PAGES
+	});
+}
+/**
+* The whole merge request diff (merge base → head, as GitLab shows it) or
+* one of its commits against its parent, as a unified diff. With
+* `expectedHeadSha`, a head that moves before or during the read fails.
+*/
+function fetchGitLabChangeRequestDiff(call, input) {
+	const operation = "getChangeRequestDiff";
+	return Effect.gen(function* () {
+		const ref = yield* requireGitLabMergeRequestRef(operation, input.reference);
+		const verifyHead = () => getGitLabMergeRequestFacts(call, operation, ref).pipe(Effect.flatMap((facts) => facts.headSha === input.expectedHeadSha ? Effect.void : Effect.fail(gitLabStaleHeadError(operation))));
+		if (input.expectedHeadSha) yield* verifyHead();
+		const commitSha = input.commitSha?.trim();
+		let entries;
+		if (commitSha) {
+			const commits = yield* listCommitShas(call, operation, ref);
+			const wanted = commitSha.toLowerCase();
+			const matches = commits.items.filter((commit) => wanted.length >= 7 ? commit.id.toLowerCase().startsWith(wanted) : commit.id.toLowerCase() === wanted);
+			const commit = matches.length === 1 ? matches[0] : void 0;
+			if (!commit || !isGitSha(commit.id)) return yield* fail(operation, `Commit ${commitSha} is not part of merge request !${ref.iid}.`);
+			entries = yield* getGitLabPages(call, operation, {
+				ref,
+				endpoint: gitLabProjectEndpoint(ref, `/repository/commits/${commit.id}/diff`),
+				item: GitLabDiffEntrySchema,
+				maxPages: DIFF_MAX_PAGES,
+				maxOutputBytes: DIFF_PAGE_MAX_BYTES,
+				timeoutMs: DIFF_TIMEOUT_MS
+			});
+		} else entries = yield* getDiffEntries(call, operation, ref, DIFF_MAX_PAGES);
+		if (entries.truncated) return yield* fail(operation, "This diff has too many files to display.");
+		if (input.expectedHeadSha) yield* verifyHead();
+		return buildGitLabUnifiedDiff(entries.items);
+	});
+}
+function isRepositoryFilePath(path) {
+	return path.length > 0 && !path.startsWith("/") && !path.split("/").some((segment) => segment === "" || segment === "." || segment === "..");
+}
+function fetchFileAtRevision(call, operation, ref, path, revision) {
+	return call(operation, gitLabGet(ref, withGitLabQuery(gitLabProjectEndpoint(ref, `/repository/files/${encodeURIComponent(path)}/raw`), { ref: revision })), {
+		maxOutputBytes: CHANGE_REQUEST_FILE_CONTENTS_MAX_BYTES,
+		truncateOutputAtMaxBytes: true
+	}).pipe(Effect.map((output) => output.stdout.includes("\0") ? {
+		contents: null,
+		truncated: false
+	} : {
+		contents: output.stdout,
+		truncated: output.stdoutTruncated
+	}), Effect.catchIf(isStatus(404), () => Effect.succeed({
+		contents: null,
+		truncated: false
+	})));
+}
+function fetchGitLabFileContents(call, input) {
+	const operation = "getChangeRequestFileContents";
+	return Effect.gen(function* () {
+		for (const path of [input.path, input.previousPath]) if (path !== void 0 && !isRepositoryFilePath(path)) return yield* fail(operation, `Invalid repository file path: ${path}`);
+		for (const sha of [input.headSha, input.baseSha]) if (sha !== void 0 && !isGitSha(sha)) return yield* fail(operation, `Invalid commit SHA: ${sha}`);
+		const ref = yield* requireGitLabMergeRequestRef(operation, input.reference);
+		let baseSha = input.baseSha;
+		if (!baseSha) {
+			const facts = yield* getGitLabMergeRequestFacts(call, operation, ref);
+			baseSha = facts.diffRefs && facts.diffRefs.head_sha === input.headSha ? facts.diffRefs.base_sha : (yield* getJson(call, operation, gitLabGet(ref, withGitLabQuery(gitLabProjectEndpoint(ref, "/repository/merge_base"), { refs: [facts.targetBranch, input.headSha] })), GitLabCommitSchema)).id;
+		}
+		const [oldSide, newSide] = yield* Effect.all([fetchFileAtRevision(call, operation, ref, input.previousPath ?? input.path, baseSha), fetchFileAtRevision(call, operation, ref, input.path, input.headSha)], { concurrency: 2 });
+		return {
+			path: input.path,
+			oldContents: oldSide.contents,
+			newContents: newSide.contents,
+			truncated: oldSide.truncated || newSide.truncated
+		};
+	});
+}
+function parseGitLabVersion(version) {
+	const match = /^(\d+)\.(\d+)/u.exec(version.trim());
+	return match?.[1] && match[2] ? {
+		major: Number(match[1]),
+		minor: Number(match[2])
+	} : null;
+}
+function gitLabSupportsReviewerState(version) {
+	const parsed = parseGitLabVersion(version);
+	if (!parsed) return false;
+	return parsed.major > REQUEST_CHANGES_MIN_VERSION.major || parsed.major === REQUEST_CHANGES_MIN_VERSION.major && parsed.minor >= REQUEST_CHANGES_MIN_VERSION.minor;
+}
+const GitLabVersionInfoSchema = Schema.Struct({ version: Schema.String });
+const GitLabCreatedIdSchema = Schema.Struct({ id: Schema.Number });
+/**
+* A review is GitLab's pending-draft flow: each comment (and the summary) is
+* created as a draft note on the reviewed head, then `bulk_publish` publishes
+* them together with any drafts the viewer started on the web. An approval
+* carries `sha`, so GitLab refuses it (409) when the head moved.
+*/
+function submitGitLabReview(call, input) {
+	const operation = "submitChangeRequestReview";
+	return Effect.gen(function* () {
+		const ref = yield* requireGitLabMergeRequestRef(operation, input.reference);
+		const facts = yield* getGitLabMergeRequestFacts(call, operation, ref);
+		if (facts.headSha !== input.expectedHeadSha) return yield* gitLabStaleHeadError(operation);
+		if (input.event === "request_changes") {
+			const version = yield* getJson(call, operation, gitLabGet(ref, "version"), GitLabVersionInfoSchema);
+			if (!gitLabSupportsReviewerState(version.version)) return yield* fail(operation, `This GitLab instance (${version.version}) cannot record "request changes" through its API; it needs GitLab ${REQUEST_CHANGES_MIN_VERSION.major}.${REQUEST_CHANGES_MIN_VERSION.minor} or later.`);
+		}
+		const bodies = [];
+		if (input.comments.length > 0) {
+			const diffRefs = facts.diffRefs;
+			if (!diffRefs) return yield* fail(operation, "GitLab has not computed this merge request's diff yet.");
+			const entries = yield* getDiffEntries(call, operation, ref, DIFF_MAX_PAGES);
+			for (const comment of input.comments) {
+				const built = buildGitLabDraftNoteBody({
+					comment,
+					diffRefs,
+					entries: entries.items
+				});
+				if (Result.isFailure(built)) return yield* fail(operation, built.failure);
+				bodies.push(built.success);
+			}
+		}
+		if ((input.body?.trim() ?? "").length > 0) bodies.push({ note: input.body });
+		const existing = yield* getGitLabPages(call, operation, {
+			ref,
+			endpoint: gitLabMergeRequestEndpoint(ref, "/draft_notes"),
+			item: GitLabDraftNoteSchema,
+			maxPages: 1
+		}).pipe(Effect.map((page) => page.items.length));
+		if (input.event === "comment" && bodies.length === 0 && existing === 0) return yield* fail(operation, "Add a comment before submitting a review.");
+		const created = [];
+		const discardCreated = Effect.suspend(() => Effect.forEach([...created], (id) => call(operation, gitLabWrite(ref, "DELETE", gitLabMergeRequestEndpoint(ref, `/draft_notes/${id}`))).pipe(Effect.ignore), { discard: true }));
+		yield* Effect.forEach(bodies, (body) => call(operation, gitLabWrite(ref, "POST", gitLabMergeRequestEndpoint(ref, "/draft_notes"), body)).pipe(Effect.flatMap((output) => decodeJson(operation, GitLabCreatedIdSchema, output.stdout)), Effect.tap((draft) => Effect.sync(() => created.push(draft.id)))), { discard: true }).pipe(Effect.tapError(() => discardCreated));
+		if (input.event === "approve") yield* call(operation, gitLabWrite(ref, "POST", gitLabMergeRequestEndpoint(ref, "/approve"), { sha: input.expectedHeadSha })).pipe(Effect.mapError((error) => error.status === 409 ? gitLabStaleHeadError(operation) : error.status === 401 || error.status === 403 ? fail(operation, "GitLab did not accept your approval: you are not an eligible approver for this merge request.", error.status) : error), Effect.tapError(() => discardCreated));
+		if (created.length + existing > 0 || input.event === "request_changes") yield* call(operation, gitLabWrite(ref, "POST", gitLabMergeRequestEndpoint(ref, "/draft_notes/bulk_publish"), input.event === "request_changes" ? { reviewer_state: "requested_changes" } : void 0)).pipe(Effect.mapError((error) => input.event === "approve" ? fail(operation, `Approved, but publishing the review comments failed; they are kept as pending drafts. ${error.detail}`, error.status) : error));
+		if (input.event === "request_changes") yield* verifyGitLabChangesRequested(call, operation, ref);
+		const lastId = created.at(-1);
+		return {
+			reviewId: lastId !== void 0 ? `draft-note:${lastId}` : input.event === "approve" ? `approval:${input.expectedHeadSha}` : "draft-notes",
+			state: input.event === "approve" ? "approved" : input.event === "request_changes" ? "changes_requested" : "commented",
+			url: facts.webUrl
+		};
+	});
+}
+/**
+* `bulk_publish` answers 204 even when GitLab's `UpdateReviewerStateService`
+* refused the state: the viewer cannot update the merge request (a Reporter,
+* an external contributor), or is not a reviewer and cannot be added (Free
+* allows one reviewer). The reviewers are re-read so a refused change request
+* is reported instead of claimed. When that read fails the outcome is unknown
+* and the submission stands; the next activity read shows what GitLab kept.
+*/
+function verifyGitLabChangesRequested(call, operation, ref) {
+	return Effect.gen(function* () {
+		const read = yield* Effect.all({
+			viewer: getCurrentUser(call, operation, ref),
+			reviewers: getJson(call, operation, gitLabGet(ref, gitLabMergeRequestEndpoint(ref, "/reviewers")), Schema.Array(GitLabReviewerSchema))
+		}, { concurrency: 2 }).pipe(Effect.option);
+		if (Option.isNone(read)) return;
+		const { viewer, reviewers } = read.value;
+		if (reviewers.find((reviewer) => reviewer.user.id === viewer.id || reviewer.user.username?.toLowerCase() === viewer.username.toLowerCase())?.state?.trim().toLowerCase() === "requested_changes") return;
+		return yield* fail(operation, "Your review was published, but GitLab did not record your change request: you need to be a reviewer of this merge request with permission to update it.");
+	});
+}
+function replyToGitLabThread(call, input) {
+	const operation = "replyToReviewThread";
+	return Effect.gen(function* () {
+		const ref = yield* requireGitLabMergeRequestRef(operation, input.reference);
+		if (!isGitLabDiscussionId(input.threadId)) return yield* fail(operation, `Unknown review thread: ${input.threadId}`);
+		yield* call(operation, gitLabWrite(ref, "POST", gitLabMergeRequestEndpoint(ref, `/discussions/${input.threadId}/notes`), { body: input.body }));
+		return yield* fetchGitLabReviewThread(call, operation, ref, input.threadId);
+	});
+}
+function setGitLabThreadResolved(call, input) {
+	const operation = "setReviewThreadResolved";
+	return Effect.gen(function* () {
+		const ref = yield* requireGitLabMergeRequestRef(operation, input.reference);
+		if (!isGitLabDiscussionId(input.threadId)) return yield* fail(operation, `Unknown review thread: ${input.threadId}`);
+		const output = yield* call(operation, gitLabWrite(ref, "PUT", withGitLabQuery(gitLabMergeRequestEndpoint(ref, `/discussions/${input.threadId}`), { resolved: input.resolved })));
+		const discussion = yield* decodeJson(operation, GitLabDiscussionSchema, output.stdout);
+		const resolvable = discussion.notes.filter((note) => note.resolvable === true);
+		const isResolved = resolvable.length > 0 ? resolvable.every((note) => note.resolved === true) : discussion.resolved === true;
+		const resolvedBy = isResolved ? resolvable.map((note) => note.resolved_by?.username?.trim()).findLast(Boolean) : void 0;
+		return {
+			threadId: discussion.id,
+			isResolved,
+			...resolvedBy ? { resolvedBy } : {}
+		};
+	});
+}
+/** Top-level notes, diff notes, and review summaries are all notes on GitLab. */
+function updateGitLabComment(call, input) {
+	const operation = "updateChangeRequestComment";
+	return Effect.gen(function* () {
+		const ref = yield* requireGitLabMergeRequestRef(operation, input.reference);
+		if (!isGitLabNumericId(input.commentId)) return yield* fail(operation, `Unknown comment: ${input.commentId}`);
+		const endpoint = gitLabMergeRequestEndpoint(ref, `/notes/${input.commentId}`);
+		if (input.action === "delete") {
+			yield* call(operation, gitLabWrite(ref, "DELETE", endpoint));
+			return {
+				commentId: input.commentId,
+				deleted: true
+			};
+		}
+		yield* call(operation, gitLabWrite(ref, "PUT", endpoint, { body: input.body }));
+		return {
+			commentId: input.commentId,
+			deleted: false
+		};
+	});
+}
+function addGitLabComment(call, input) {
+	const operation = "addChangeRequestComment";
+	return Effect.gen(function* () {
+		const ref = yield* requireGitLabMergeRequestRef(operation, input.reference);
+		yield* call(operation, gitLabWrite(ref, "POST", gitLabMergeRequestEndpoint(ref, "/notes"), { body: input.body }));
+	});
+}
+const GitLabUserLookupSchema = Schema.Struct({
+	id: Schema.Number,
+	username: Schema.String
+});
+function resolveUserIds(call, operation, ref, logins) {
+	return Effect.forEach(logins, (login) => getJson(call, operation, gitLabGet(ref, withGitLabQuery("users", { username: login })), Schema.Array(GitLabUserLookupSchema)).pipe(Effect.flatMap((users) => {
+		const match = users.find((user) => user.username.toLowerCase() === login.trim().toLowerCase());
+		return match ? Effect.succeed(match.id) : Effect.fail(fail(operation, `No GitLab user named @${login}.`));
+	})), { concurrency: 4 });
+}
+/** The full id list GitLab's update takes: current minus removed plus added. */
+function nextGitLabUserIds(input) {
+	const removed = new Set(input.removeLogins.map((login) => login.trim().toLowerCase()));
+	const ids = input.current.flatMap((user) => typeof user.id === "number" && !removed.has(user.username?.trim().toLowerCase() ?? "") ? [user.id] : []);
+	for (const id of input.addIds) if (!ids.includes(id)) ids.push(id);
+	return ids.length > 0 ? ids : [0];
+}
+const GitLabCancelAutoMergeSchema = Schema.Struct({
+	status: Schema.optional(Schema.NullOr(Schema.String)),
+	message: Schema.optional(Schema.NullOr(Schema.String))
+});
+function deleteSourceBranch(call, operation, ref, facts) {
+	if (facts.isCrossRepository) return Effect.fail(fail(operation, "The source branch lives in a fork, which Ryco does not delete."));
+	return call(operation, gitLabWrite(ref, "DELETE", gitLabProjectEndpoint(ref, `/repository/branches/${encodeURIComponent(facts.sourceBranch)}`))).pipe(Effect.asVoid);
+}
+/** Apply one lifecycle action; the provider re-reads the detail afterwards. */
+function updateGitLabMergeRequest(call, input) {
+	const operation = "updateChangeRequest";
+	return Effect.gen(function* () {
+		const ref = yield* requireGitLabMergeRequestRef(operation, input.reference);
+		const endpoint = gitLabMergeRequestEndpoint(ref);
+		const update = (body) => call(operation, gitLabWrite(ref, "PUT", endpoint, body)).pipe(Effect.asVoid);
+		const action = input.action;
+		switch (action.kind) {
+			case "edit": {
+				const body = {
+					...action.title !== void 0 ? { title: action.title } : {},
+					...action.body !== void 0 ? { description: action.body } : {},
+					...action.baseRefName !== void 0 ? { target_branch: action.baseRefName } : {}
+				};
+				if (Object.keys(body).length === 0) return yield* fail(operation, "Nothing to update.");
+				return yield* update(body);
+			}
+			case "set-draft": {
+				const facts = yield* getGitLabMergeRequestFacts(call, operation, ref);
+				if (facts.isDraft === action.draft) return;
+				return yield* update({ title: gitLabDraftTitle(facts.title, action.draft) });
+			}
+			case "close":
+				yield* update({ state_event: "close" });
+				if (action.deleteBranch === true) {
+					const facts = yield* getGitLabMergeRequestFacts(call, operation, ref);
+					yield* deleteSourceBranch(call, operation, ref, facts);
+				}
+				return;
+			case "reopen": return yield* update({ state_event: "reopen" });
+			case "labels": {
+				const body = {
+					...action.add.length > 0 ? { add_labels: action.add.join(",") } : {},
+					...action.remove.length > 0 ? { remove_labels: action.remove.join(",") } : {}
+				};
+				if (Object.keys(body).length === 0) return;
+				return yield* update(body);
+			}
+			case "reviewers":
+			case "assignees": {
+				if (action.add.length === 0 && action.remove.length === 0) return;
+				const facts = yield* getGitLabMergeRequestFacts(call, operation, ref);
+				const addIds = yield* resolveUserIds(call, operation, ref, action.add);
+				const ids = nextGitLabUserIds({
+					current: action.kind === "reviewers" ? facts.reviewers : facts.assignees,
+					removeLogins: action.remove,
+					addIds
+				});
+				return yield* update(action.kind === "reviewers" ? { reviewer_ids: ids } : { assignee_ids: ids });
+			}
+			case "update-branch":
+				if (action.method !== "rebase") return yield* fail(operation, "GitLab updates a merge request's branch by rebasing it; merging the target branch in is not available.");
+				if ((yield* getGitLabMergeRequestFacts(call, operation, ref)).headSha !== action.expectedHeadSha) return yield* gitLabStaleHeadError(operation);
+				yield* call(operation, gitLabWrite(ref, "PUT", gitLabMergeRequestEndpoint(ref, "/rebase")));
+				return;
+			case "auto-merge": {
+				if (!action.enabled) {
+					const output = yield* call(operation, gitLabWrite(ref, "POST", gitLabMergeRequestEndpoint(ref, "/cancel_merge_when_pipeline_succeeds")));
+					const result = yield* decodeJson(operation, GitLabCancelAutoMergeSchema, output.stdout);
+					if (result.status?.trim().toLowerCase() === "error") return yield* fail(operation, result.message?.trim() || "GitLab could not cancel the automatic merge.");
+					return;
+				}
+				const [facts, project] = yield* Effect.all([getGitLabMergeRequestFacts(call, operation, ref), getProject(call, operation, ref)], { concurrency: 2 });
+				if (action.expectedHeadSha && facts.headSha !== action.expectedHeadSha) return yield* gitLabStaleHeadError(operation);
+				if (action.mergeMethod && !gitLabMergeCapabilities(project)[action.mergeMethod]) return yield* fail(operation, `The ${action.mergeMethod} merge method is not available for this project.`);
+				const sha = action.expectedHeadSha ?? facts.headSha;
+				yield* call(operation, gitLabWrite(ref, "PUT", gitLabMergeRequestEndpoint(ref, "/merge"), {
+					auto_merge: true,
+					merge_when_pipeline_succeeds: true,
+					...sha ? { sha } : {},
+					...action.mergeMethod ? { squash: action.mergeMethod === "squash" } : {}
+				})).pipe(Effect.mapError((error) => mergeError(operation, error)));
+				return;
+			}
+			case "delete-branch": {
+				const facts = yield* getGitLabMergeRequestFacts(call, operation, ref);
+				return yield* deleteSourceBranch(call, operation, ref, facts);
+			}
+		}
+	});
+}
+function mergeError(operation, error) {
+	switch (error.status) {
+		case 409: return gitLabStaleHeadError(operation);
+		case 401: return fail(operation, "You do not have permission to merge this merge request.", 401);
+		case 405: return fail(operation, "GitLab cannot merge this merge request right now (HTTP 405). Check its pipeline, approvals, open threads, conflicts and draft status.", 405);
+		case 422: return fail(operation, `GitLab could not merge the branch (HTTP 422). ${error.detail}`, 422);
+		default: return error;
+	}
+}
+const GitLabMergeResultSchema = Schema.Struct({ state: Schema.optional(Schema.NullOr(Schema.String)) });
+/**
+* `PUT .../merge` with `sha` (GitLab refuses a moved head with 409). The
+* merge method is the project's (merge commit or fast-forward), so only it
+* and squash are accepted. A merge request GitLab queues (merge train,
+* pending pipeline) reports `enqueued`.
+*/
+function mergeGitLabMergeRequest(call, input) {
+	const operation = "mergeChangeRequest";
+	return Effect.gen(function* () {
+		const ref = yield* requireGitLabMergeRequestRef(operation, input.reference);
+		const [facts, project] = yield* Effect.all([getGitLabMergeRequestFacts(call, operation, ref), getProject(call, operation, ref)], { concurrency: 2 });
+		if (input.expectedHeadSha && facts.headSha !== input.expectedHeadSha) return yield* gitLabStaleHeadError(operation);
+		if (!gitLabMergeCapabilities(project)[input.mergeMethod]) return yield* fail(operation, `The ${input.mergeMethod} merge method is not available for this project.`);
+		const output = yield* call(operation, gitLabWrite(ref, "PUT", gitLabMergeRequestEndpoint(ref, "/merge"), {
+			squash: input.mergeMethod === "squash",
+			...input.expectedHeadSha ? { sha: input.expectedHeadSha } : {},
+			...input.deleteBranch !== void 0 ? { should_remove_source_branch: input.deleteBranch } : {}
+		})).pipe(Effect.mapError((error) => mergeError(operation, error)));
+		return { outcome: (yield* decodeJson(operation, GitLabMergeResultSchema, output.stdout)).state?.trim().toLowerCase() === "merged" ? "merged" : "enqueued" };
+	});
+}
+function toDetailCommit(commit) {
+	const oid = commit.id.trim();
+	if (!oid) return null;
+	const author = commit.author_name?.trim();
+	const committedDate = commit.committed_date?.trim();
+	return {
+		oid,
+		shortOid: commit.short_id?.trim() || oid.slice(0, 8),
+		messageHeadline: commit.title?.trim() ?? (commit.message ?? "").split("\n")[0]?.trim() ?? "",
+		...committedDate ? { committedDate } : {},
+		...author ? { author } : {}
+	};
+}
+const GitLabCommitParentsSchema = Schema.Struct({
+	id: Schema.String,
+	parent_ids: Schema.optional(Schema.NullOr(Schema.Array(Schema.String)))
+});
+/**
+* `head_pipeline` when it verifies the current head: on the head commit, or
+* on a merged-results or merge-train commit that has the head as a parent.
+* Any other SHA is an earlier head's pipeline (GitLab keeps it after a push
+* that started none), which would show stale checks, so it is dropped; so is
+* one whose merge commit cannot be read.
+*/
+function resolveGitLabHeadPipeline(call, operation, ref, facts) {
+	const pipeline = facts.headPipeline;
+	const head = facts.headSha?.toLowerCase() ?? null;
+	const sha = pipeline?.sha?.toLowerCase() ?? null;
+	if (!pipeline || !sha || !head || !isGitSha(sha)) return Effect.succeed(null);
+	const resolved = {
+		id: pipeline.id,
+		sha,
+		runName: gitLabPipelineRunName(pipeline)
+	};
+	if (sha === head) return Effect.succeed(resolved);
+	return optional(getJson(call, operation, gitLabGet(ref, gitLabProjectEndpoint(ref, `/repository/commits/${sha}`)), GitLabCommitParentsSchema), null).pipe(Effect.map((commit) => commit?.parent_ids?.some((parent) => parent.toLowerCase() === head) === true ? resolved : null));
+}
+/**
+* Readiness facts for the detail: reviewers' states and approvals, the merge
+* state, the project's merge methods, head pipeline statuses and commits.
+* Each read is optional; a failed one leaves its facts out (never guessed).
+*/
+function fetchGitLabDetailReadiness(call, facts, reference) {
+	const operation = "getChangeRequestDetail";
+	return Effect.gen(function* () {
+		const ref = yield* requireGitLabMergeRequestRef(operation, reference);
+		const headPipeline = yield* resolveGitLabHeadPipeline(call, operation, ref, facts);
+		const statusSha = headPipeline?.sha ?? facts.headSha;
+		const read = yield* Effect.all({
+			reviewers: optional(getJson(call, operation, gitLabGet(ref, gitLabMergeRequestEndpoint(ref, "/reviewers")), Schema.Array(GitLabReviewerSchema)), null),
+			approvals: optional(getJson(call, operation, gitLabGet(ref, gitLabMergeRequestEndpoint(ref, "/approvals")), GitLabApprovalStateSchema), null),
+			project: optional(getProject(call, operation, ref), null),
+			statuses: statusSha && isGitSha(statusSha) ? optional(getGitLabPages(call, operation, {
+				ref,
+				endpoint: gitLabProjectEndpoint(ref, `/repository/commits/${statusSha}/statuses`),
+				item: GitLabCommitStatusSchema,
+				maxPages: 1
+			}).pipe(Effect.map((page) => page.items)), null) : Effect.succeed(null),
+			headJobs: headPipeline ? optional(getGitLabPages(call, operation, {
+				ref,
+				endpoint: gitLabProjectEndpoint(ref, `/pipelines/${headPipeline.id}/jobs`),
+				item: GitLabJobSchema,
+				maxPages: 1
+			}).pipe(Effect.map((page) => page.items)), null) : Effect.succeed(null),
+			commits: optional(getGitLabPages(call, operation, {
+				ref,
+				endpoint: gitLabMergeRequestEndpoint(ref, "/commits"),
+				item: GitLabCommitSchema,
+				maxPages: 1
+			}).pipe(Effect.map((page) => page.items)), null)
+		}, { concurrency: 6 });
+		const reviewerStates = read.reviewers !== null ? gitLabReviewerStates({
+			reviewers: read.reviewers,
+			approvals: read.approvals
+		}) : null;
+		const reviewDecision = reviewerStates !== null && read.approvals !== null ? gitLabReviewDecision({
+			reviewerStates,
+			approvals: read.approvals
+		}) : void 0;
+		const mergeStateStatus = facts.isDraft ? "draft" : gitLabMergeStateStatus(facts.detailedMergeStatus);
+		const reviewers = facts.reviewers.flatMap((user) => user.username?.trim() ? [user.username.trim()] : []);
+		const commits = read.commits?.flatMap((commit) => {
+			const mapped = toDetailCommit(commit);
+			return mapped ? [mapped] : [];
+		}).toReversed();
+		const checkRollup = read.statuses !== null ? gitLabCheckRollup(read.statuses, headPipeline && read.headJobs ? {
+			runName: headPipeline.runName,
+			jobs: read.headJobs
+		} : null) : null;
+		return {
+			...facts.headSha ? { headSha: facts.headSha } : {},
+			...reviewerStates !== null ? { reviewerStates } : {},
+			...reviewDecision !== void 0 ? { reviewDecision } : {},
+			...mergeStateStatus ? { mergeStateStatus } : {},
+			...read.project !== null ? { mergeCapabilities: gitLabMergeCapabilities(read.project) } : {},
+			...facts.state === "open" && read.project !== null ? { autoMerge: gitLabAutoMerge({
+				facts,
+				project: read.project
+			}) } : {},
+			...facts.forceRemoveSourceBranch !== null ? { deleteBranchOnMerge: facts.forceRemoveSourceBranch } : {},
+			...checkRollup !== null ? { checkRollup } : {},
+			...commits && commits.length > 0 ? { commits } : {},
+			...reviewers.length > 0 ? { reviewers } : {},
+			...facts.closedAt && facts.state === "closed" ? { closedAt: facts.closedAt } : {},
+			...facts.mergedAt ? { mergedAt: facts.mergedAt } : {},
+			...facts.mergedBy && facts.state === "merged" ? { mergedBy: facts.mergedBy } : {},
+			...facts.changesCount !== null ? { changedFiles: facts.changesCount } : {}
+		};
+	});
+}
+const STATE_QUERY = {
+	open: "opened",
+	closed: "closed",
+	merged: "merged",
+	all: "all"
+};
+/**
+* A server-side filtered list: involvement relative to the authenticated
+* user (`author_username`, `reviewer_username`, `assignee_id`), free-text
+* `search`, state, and source branch. GitLab has no "mentioned" or
+* "involved" filter, so those fail instead of returning everything.
+*/
+function listGitLabMergeRequestsFiltered(call, input) {
+	const operation = "listChangeRequests";
+	return Effect.gen(function* () {
+		let involvementQuery = {};
+		if (input.involvement !== void 0) {
+			if (input.involvement === "mentioned" || input.involvement === "involved") return yield* fail(operation, `GitLab cannot filter merge requests by "${input.involvement}"; use authored, review requested, or assigned.`);
+			const user = yield* getCurrentUser(call, operation, null);
+			involvementQuery = input.involvement === "authored" ? { author_username: user.username } : input.involvement === "review-requested" ? { reviewer_username: user.username } : { assignee_id: user.id };
+		}
+		const query = input.query?.trim();
+		const output = yield* call(operation, gitLabGet(null, withGitLabQuery(gitLabProjectEndpoint(CURRENT_GITLAB_PROJECT, "/merge_requests"), {
+			state: STATE_QUERY[input.state],
+			...involvementQuery,
+			...query ? { search: query } : {},
+			...input.sourceBranch ? { source_branch: input.sourceBranch } : {},
+			order_by: "updated_at",
+			sort: "desc",
+			per_page: Math.min(Math.max(input.limit ?? 20, 1), 100)
+		})), { maxOutputBytes: LIST_PAGE_MAX_BYTES });
+		const decoded = decodeGitLabMergeRequestListJson(output.stdout.trim() || "[]");
+		return Result.isSuccess(decoded) ? decoded.success : yield* fail(operation, "GitLab returned an unexpected merge request list.");
+	});
+}
+/** One rollup per list row from the project's recent pipelines (one request for the page). */
+function enrichGitLabListRowsWithPipelines(call, rows) {
+	if (!rows.some((row) => row.state === "open")) return Effect.succeed(rows);
+	return optional(getGitLabPages(call, "listChangeRequests", {
+		ref: null,
+		endpoint: gitLabProjectEndpoint(CURRENT_GITLAB_PROJECT, "/pipelines"),
+		item: GitLabPipelineSchema,
+		maxPages: 1
+	}).pipe(Effect.map((page) => page.items)), []).pipe(Effect.map((pipelines) => rows.map((row) => {
+		if (row.state !== "open" || row.checkRollup) return row;
+		const checkRollup = gitLabListRowRollup(pipelines, {
+			iid: row.number,
+			sourceBranch: row.headRefName,
+			headSha: row.headSha ?? null
+		});
+		return checkRollup ? {
+			...row,
+			checkRollup
+		} : row;
+	})));
+}
+const GitLabLabelSchema = Schema.Struct({
+	name: Schema.String,
+	color: Schema.optional(Schema.NullOr(Schema.String)),
+	description: Schema.optional(Schema.NullOr(Schema.String))
+});
+const GitLabMemberSchema = Schema.Struct({
+	username: Schema.String,
+	name: Schema.optional(Schema.NullOr(Schema.String)),
+	avatar_url: Schema.optional(Schema.NullOr(Schema.String)),
+	state: Schema.optional(Schema.NullOr(Schema.String))
+});
+function listGitLabLabels(call) {
+	return getGitLabPages(call, "listLabels", {
+		ref: null,
+		endpoint: gitLabProjectEndpoint(CURRENT_GITLAB_PROJECT, "/labels"),
+		item: GitLabLabelSchema,
+		maxPages: 3
+	}).pipe(Effect.map((page) => page.items.flatMap((label) => {
+		const name = label.name.trim();
+		if (!name) return [];
+		const color = label.color?.trim().replace(/^#/u, "").toLowerCase();
+		const description = label.description?.trim();
+		return [{
+			name,
+			...color && /^[0-9a-f]{3,8}$/u.test(color) ? { color } : {},
+			...description ? { description } : {}
+		}];
+	})));
+}
+/** Active members, inherited ones included (reviewer and assignee candidates). */
+function listGitLabAssignees(call) {
+	return getGitLabPages(call, "listAssignees", {
+		ref: null,
+		endpoint: gitLabProjectEndpoint(CURRENT_GITLAB_PROJECT, "/members/all"),
+		item: GitLabMemberSchema,
+		maxPages: 3
+	}).pipe(Effect.map((page) => page.items.flatMap((member) => {
+		const login = member.username.trim();
+		if (!login || member.state && member.state !== "active") return [];
+		const displayName = member.name?.trim();
+		const avatarUrl = member.avatar_url?.trim();
+		return [{
+			login,
+			...displayName ? { displayName } : {},
+			...avatarUrl ? { avatarUrl } : {}
+		}];
+	})));
+}
+function requireNumericId(operation, label, value) {
+	return isGitLabNumericId(value) ? Effect.succeed(value) : Effect.fail(fail(operation, `Unknown ${label}: ${value}`));
+}
+/**
+* Pipelines for a merge request's head (`pullRequestNumber`), a commit, or a
+* branch's newest commit, newest first.
+*/
+function listGitLabWorkflowRuns(call, input) {
+	const operation = "listWorkflowRuns";
+	return Effect.gen(function* () {
+		const perPage = Math.min(Math.max(input.limit ?? 50, 1), 100);
+		const project = CURRENT_GITLAB_PROJECT;
+		let pipelines;
+		let sourceHeadOf = () => null;
+		let headSha = input.commitSha?.trim() || null;
+		if (headSha !== null && !isGitSha(headSha)) return yield* fail(operation, `Invalid commit SHA: ${headSha}`);
+		if (input.pullRequestNumber !== void 0) {
+			const ref = {
+				...project,
+				iid: input.pullRequestNumber
+			};
+			const facts = yield* getGitLabMergeRequestFacts(call, operation, ref);
+			headSha = headSha ?? facts.headSha;
+			const { page, headPipeline } = yield* Effect.all({
+				page: getGitLabPages(call, operation, {
+					ref,
+					endpoint: gitLabMergeRequestEndpoint(ref, "/pipelines"),
+					item: GitLabPipelineSchema,
+					maxPages: 1,
+					perPage
+				}),
+				headPipeline: input.commitSha ? Effect.succeed(null) : resolveGitLabHeadPipeline(call, operation, ref, facts)
+			}, { concurrency: 2 });
+			pipelines = selectGitLabHeadPipelines(page.items, {
+				headSha,
+				headPipelineId: headPipeline?.id ?? null
+			});
+			sourceHeadOf = (pipeline) => pipeline.id === headPipeline?.id ? facts.headSha : null;
+		} else if (headSha !== null) pipelines = (yield* getGitLabPages(call, operation, {
+			ref: null,
+			endpoint: withGitLabQuery(gitLabProjectEndpoint(project, "/pipelines"), { sha: headSha }),
+			item: GitLabPipelineSchema,
+			maxPages: 1,
+			perPage
+		})).items;
+		else if (input.branch?.trim()) {
+			const page = yield* getGitLabPages(call, operation, {
+				ref: null,
+				endpoint: withGitLabQuery(gitLabProjectEndpoint(project, "/pipelines"), { ref: input.branch.trim() }),
+				item: GitLabPipelineSchema,
+				maxPages: 1,
+				perPage
+			});
+			headSha = page.items[0]?.sha ?? null;
+			pipelines = page.items.filter((pipeline) => pipeline.sha === headSha);
+		} else pipelines = [];
+		return {
+			provider: "gitlab",
+			repository: Option.none(),
+			pullRequestNumber: input.pullRequestNumber !== void 0 ? Option.some(input.pullRequestNumber) : Option.none(),
+			headSha: headSha ? Option.some(headSha) : Option.none(),
+			runs: pipelines.flatMap((pipeline) => {
+				const run = gitLabWorkflowRun(pipeline, sourceHeadOf(pipeline));
+				return run ? [run] : [];
+			})
+		};
+	});
+}
+function listGitLabPipelineJobs(call, runId) {
+	const operation = "getWorkflowRunJobs";
+	return Effect.gen(function* () {
+		yield* requireNumericId(operation, "pipeline", runId);
+		return {
+			provider: "gitlab",
+			runId,
+			jobs: (yield* getGitLabPages(call, operation, {
+				ref: null,
+				endpoint: gitLabProjectEndpoint(CURRENT_GITLAB_PROJECT, `/pipelines/${runId}/jobs`),
+				item: GitLabJobSchema,
+				maxPages: 3
+			})).items.toSorted((left, right) => left.id - right.id).map(gitLabWorkflowJob)
+		};
+	});
+}
+function getGitLabJobLog(call, input) {
+	const operation = "getWorkflowJobLog";
+	return Effect.gen(function* () {
+		yield* requireNumericId(operation, "job", input.jobId);
+		const output = yield* call(operation, gitLabGet(null, gitLabProjectEndpoint(CURRENT_GITLAB_PROJECT, `/jobs/${input.jobId}/trace`)), {
+			maxOutputBytes: JOB_LOG_TAIL_BYTES,
+			keepOutputTail: true,
+			timeoutMs: 6e4
+		});
+		const tail = gitLabJobLogTail(output.stdout, { startCut: output.stdoutTruncated });
+		return {
+			provider: "gitlab",
+			runId: input.runId,
+			jobId: input.jobId,
+			log: tail.log,
+			truncated: tail.truncated || output.stdoutTruncated
+		};
+	});
+}
+/** `failed-jobs` retries a pipeline's failed and canceled jobs; `job` retries one. */
+function rerunGitLabPipeline(call, input) {
+	const operation = "rerunWorkflow";
+	return Effect.gen(function* () {
+		if (input.target === "job") {
+			yield* requireNumericId(operation, "job", input.jobId);
+			yield* call(operation, gitLabWrite(CURRENT_GITLAB_PROJECT, "POST", gitLabProjectEndpoint(CURRENT_GITLAB_PROJECT, `/jobs/${input.jobId}/retry`)));
+			return {
+				provider: "gitlab",
+				runId: input.runId,
+				target: "job",
+				jobId: input.jobId
+			};
+		}
+		yield* requireNumericId(operation, "pipeline", input.runId);
+		yield* call(operation, gitLabWrite(CURRENT_GITLAB_PROJECT, "POST", gitLabProjectEndpoint(CURRENT_GITLAB_PROJECT, `/pipelines/${input.runId}/retry`)));
+		return {
+			provider: "gitlab",
+			runId: input.runId,
+			target: "failed-jobs"
+		};
+	});
+}
+//#endregion
+//#region src/sourceControl/GitLabSourceControlProvider.ts
+function providerError(operation, cause) {
+	return new SourceControlProviderError({
+		provider: "gitlab",
+		operation,
+		detail: cause.detail,
+		cause
+	});
+}
+function toChangeRequest(summary) {
+	return {
+		provider: "gitlab",
+		number: summary.number,
+		title: summary.title,
+		url: summary.url,
+		baseRefName: summary.baseRefName,
+		headRefName: summary.headRefName,
+		state: summary.state ?? "open",
+		updatedAt: summary.updatedAt ?? Option.none(),
+		...summary.isCrossRepository !== void 0 ? { isCrossRepository: summary.isCrossRepository } : {},
+		...summary.headRepositoryNameWithOwner !== void 0 ? { headRepositoryNameWithOwner: summary.headRepositoryNameWithOwner } : {},
+		...summary.headRepositoryOwnerLogin !== void 0 ? { headRepositoryOwnerLogin: summary.headRepositoryOwnerLogin } : {},
+		...summary.isDraft !== void 0 ? { isDraft: summary.isDraft } : {},
+		...summary.author ? { author: summary.author } : {},
+		...summary.assignees && summary.assignees.length > 0 ? { assignees: summary.assignees } : {},
+		...summary.labels && summary.labels.length > 0 ? { labels: summary.labels } : {},
+		...summary.commentsCount !== void 0 ? { commentsCount: summary.commentsCount } : {},
+		...summary.headSha ? { headSha: summary.headSha } : {},
+		...summary.mergeability ? { mergeability: summary.mergeability } : {},
+		...summary.mergeStateStatus ? { mergeStateStatus: summary.mergeStateStatus } : {},
+		...summary.reviewDecision ? { reviewDecision: summary.reviewDecision } : {},
+		...summary.createdAt ? { createdAt: summary.createdAt } : {}
+	};
+}
+function toIssueSummary(raw) {
+	return {
+		provider: "gitlab",
+		number: raw.number,
+		title: raw.title,
+		url: raw.url,
+		state: raw.state,
+		...raw.author ? { author: raw.author } : {},
+		updatedAt: raw.updatedAt.pipe(Option.map((s) => DateTime.fromDateUnsafe(new Date(s)))),
+		labels: raw.labels.map((name) => ({ name }))
+	};
+}
+function toIssueDetail(raw, options) {
+	const content = options.fullContent ? {
+		body: raw.body,
+		comments: raw.comments,
+		truncated: false
+	} : truncateSourceControlDetailContent({
+		body: raw.body,
+		comments: raw.comments
+	});
+	return {
+		...toIssueSummary(raw),
+		body: content.body,
+		comments: content.comments.map((c) => ({
+			author: c.author,
+			body: c.body,
+			createdAt: DateTime.fromDateUnsafe(new Date(c.createdAt))
+		})),
+		truncated: content.truncated
+	};
+}
+function toChangeRequestDetail(raw, options) {
+	const content = options.fullContent ? {
+		body: raw.body,
+		comments: raw.comments,
+		truncated: false
+	} : truncateSourceControlDetailContent({
+		body: raw.body,
+		comments: raw.comments
+	});
+	return {
+		...toChangeRequest(raw),
+		body: content.body,
+		comments: content.comments.map((c) => ({
+			author: c.author,
+			body: c.body,
+			createdAt: DateTime.fromDateUnsafe(new Date(c.createdAt))
+		})),
+		truncated: content.truncated
+	};
+}
+const make = Effect.fn("makeGitLabSourceControlProvider")(function* () {
+	const gitlab = yield* GitLabCli;
+	/** The page runner for one checkout: `glab api` resolves `:fullpath` from `cwd`. */
+	const callIn = (cwd) => (operation, request, options) => gitlab.api({
+		cwd,
+		operation,
+		request,
+		...options
+	});
+	const run = (operation, effect) => effect.pipe(Effect.mapError((error) => providerError(operation, error)));
+	const getChangeRequestDetail = (input) => Effect.gen(function* () {
+		const raw = yield* gitlab.getMergeRequestDetail({
+			cwd: input.cwd,
+			reference: input.reference
+		});
+		const detail = toChangeRequestDetail(raw, { fullContent: input.fullContent ?? false });
+		if (!raw.facts) return detail;
+		const readiness = yield* fetchGitLabDetailReadiness(callIn(input.cwd), raw.facts, String(raw.number));
+		return {
+			...detail,
+			...readiness
+		};
+	}).pipe(Effect.mapError((error) => providerError("getChangeRequestDetail", error)));
+	const freshDetail = (input) => getChangeRequestDetail({
+		cwd: input.cwd,
+		reference: input.reference,
+		fullContent: true
+	});
+	const provider = SourceControlProvider.of({
+		kind: "gitlab",
+		listChangeRequests: (input) => {
+			const source = sourceControlRefFromInput(input);
+			const query = input.query?.trim() ?? "";
+			const call = callIn(input.cwd);
+			return (input.involvement !== void 0 || query.length > 0 ? listGitLabMergeRequestsFiltered(call, {
+				state: input.state,
+				involvement: input.involvement,
+				query,
+				sourceBranch: sourceBranch(input) || void 0,
+				limit: input.limit
+			}) : gitlab.listMergeRequests({
+				cwd: input.cwd,
+				headSelector: input.headSelector,
+				...source ? { source } : {},
+				state: input.state,
+				...input.limit !== void 0 ? { limit: input.limit } : {}
+			})).pipe(Effect.map((items) => items.map(toChangeRequest)), Effect.flatMap((rows) => input.headSelector.trim().length === 0 && input.includeStackSummary !== false ? enrichGitLabListRowsWithPipelines(call, rows) : Effect.succeed(rows)), Effect.mapError((error) => providerError("listChangeRequests", error)));
+		},
+		getChangeRequest: (input) => gitlab.getMergeRequest(input).pipe(Effect.map(toChangeRequest), Effect.mapError((error) => providerError("getChangeRequest", error))),
+		createChangeRequest: (input) => {
+			const source = sourceControlRefFromInput(input);
+			return gitlab.createMergeRequest({
+				cwd: input.cwd,
+				baseBranch: input.baseRefName,
+				headSelector: input.headSelector,
+				...source ? { source } : {},
+				...input.target ? { target: input.target } : {},
+				title: input.title,
+				bodyFile: input.bodyFile,
+				...input.draft === true ? { draft: true } : {}
+			}).pipe(Effect.mapError((error) => providerError("createChangeRequest", error)));
+		},
+		getRepositoryCloneUrls: (input) => gitlab.getRepositoryCloneUrls(input).pipe(Effect.mapError((error) => providerError("getRepositoryCloneUrls", error))),
+		createRepository: (input) => gitlab.createRepository(input).pipe(Effect.mapError((error) => providerError("createRepository", error))),
+		getDefaultBranch: (input) => gitlab.getDefaultBranch(input).pipe(Effect.mapError((error) => providerError("getDefaultBranch", error))),
+		checkoutChangeRequest: (input) => gitlab.checkoutMergeRequest(input).pipe(Effect.mapError((error) => providerError("checkoutChangeRequest", error))),
+		listIssues: (input) => gitlab.listIssues({
+			cwd: input.cwd,
+			state: input.state,
+			...input.limit !== void 0 ? { limit: input.limit } : {}
+		}).pipe(Effect.map((items) => items.map(toIssueSummary)), Effect.mapError((error) => providerError("listIssues", error))),
+		getIssue: (input) => gitlab.getIssue({
+			cwd: input.cwd,
+			reference: input.reference
+		}).pipe(Effect.map((raw) => toIssueDetail(raw, { fullContent: input.fullContent ?? false })), Effect.mapError((error) => providerError("getIssue", error))),
+		addIssueComment: () => Effect.fail(new SourceControlProviderError({
+			provider: "gitlab",
+			operation: "addIssueComment",
+			detail: "Not implemented for gitlab"
+		})),
+		addIssueCommentReaction: () => Effect.fail(new SourceControlProviderError({
+			provider: "gitlab",
+			operation: "addIssueCommentReaction",
+			detail: "Not implemented for gitlab"
+		})),
+		searchIssues: (input) => gitlab.searchIssues({
+			cwd: input.cwd,
+			query: input.query,
+			...input.limit !== void 0 ? { limit: input.limit } : {}
+		}).pipe(Effect.map((items) => items.map(toIssueSummary)), Effect.mapError((error) => providerError("searchIssues", error))),
+		searchChangeRequests: (input) => gitlab.searchMergeRequests({
+			cwd: input.cwd,
+			query: input.query,
+			...input.limit !== void 0 ? { limit: input.limit } : {}
+		}).pipe(Effect.map((items) => items.map(toChangeRequest)), Effect.mapError((error) => providerError("searchChangeRequests", error))),
+		getChangeRequestDetail,
+		addChangeRequestComment: (input) => run("addChangeRequestComment", addGitLabComment(callIn(input.cwd), input)).pipe(Effect.andThen(() => freshDetail(input))),
+		addChangeRequestCommentReaction: () => Effect.fail(new SourceControlProviderError({
+			provider: "gitlab",
+			operation: "addChangeRequestCommentReaction",
+			detail: "GitLab does not support comment reactions."
+		})),
+		getChangeRequestDiff: (input) => run("getChangeRequestDiff", fetchGitLabChangeRequestDiff(callIn(input.cwd), input)),
+		mergeChangeRequest: (input) => run("mergeChangeRequest", mergeGitLabMergeRequest(callIn(input.cwd), input)),
+		getChangeRequestActivity: (input) => run("getChangeRequestActivity", fetchGitLabChangeRequestActivity(callIn(input.cwd), input.reference)),
+		getChangeRequestFileContents: ({ context: _context, ...input }) => run("getChangeRequestFileContents", fetchGitLabFileContents(callIn(input.cwd), input)),
+		submitChangeRequestReview: ({ context: _context, ...input }) => run("submitChangeRequestReview", submitGitLabReview(callIn(input.cwd), input)),
+		replyToReviewThread: (input) => run("replyToReviewThread", replyToGitLabThread(callIn(input.cwd), input)).pipe(Effect.map((thread) => ({ thread }))),
+		setReviewThreadResolved: (input) => run("setReviewThreadResolved", setGitLabThreadResolved(callIn(input.cwd), input)),
+		updateChangeRequestComment: ({ context: _context, ...input }) => run("updateChangeRequestComment", updateGitLabComment(callIn(input.cwd), input)),
+		updateChangeRequest: (input) => run("updateChangeRequest", updateGitLabMergeRequest(callIn(input.cwd), input)).pipe(Effect.andThen(() => freshDetail(input)), Effect.map((detail) => ({ detail }))),
+		createIssue: () => Effect.fail(new SourceControlProviderError({
+			provider: "gitlab",
+			operation: "createIssue",
+			detail: "Not implemented in Phase 1"
+		})),
+		listLabels: (input) => run("listLabels", listGitLabLabels(callIn(input.cwd))),
+		listAssignees: (input) => run("listAssignees", listGitLabAssignees(callIn(input.cwd))),
+		getPullRequestState: (input) => gitlab.getMergeRequest({
+			cwd: input.cwd,
+			reference: String(input.number)
+		}).pipe(Effect.map((summary) => {
+			const state = summary.state ?? "open";
+			return {
+				state,
+				isDraft: summary.isDraft ?? false,
+				terminalAt: state === "merged" ? summary.mergedAt ?? summary.closedAt ?? null : state === "closed" ? summary.closedAt ?? null : null
+			};
+		}), Effect.mapError((error) => providerError("getPullRequestState", error))),
+		getIssueState: () => Effect.fail(new SourceControlProviderError({
+			provider: "gitlab",
+			operation: "getIssueState",
+			detail: "Not implemented for gitlab"
+		})),
+		listWorkflowRuns: (input) => run("listWorkflowRuns", listGitLabWorkflowRuns(callIn(input.cwd), input)),
+		getWorkflowRunJobs: (input) => run("getWorkflowRunJobs", listGitLabPipelineJobs(callIn(input.cwd), input.runId)),
+		getWorkflowJobLog: (input) => run("getWorkflowJobLog", getGitLabJobLog(callIn(input.cwd), input)),
+		rerunWorkflow: ({ context: _context, ...input }) => run("rerunWorkflow", rerunGitLabPipeline(callIn(input.cwd), input))
+	});
+	return withUnsupportedChangeRequestOptionGuards(provider);
+});
+const layer = Layer.effect(SourceControlProvider, make());
+//#endregion
+export { gitlabDiscovery as discovery, layer, make };