@dxos/plugin-github 0.7.4 → 0.14.0

package/dist/lib/chunk-PullRequestArticle.mjs

@@ -0,0 +1,1506 @@
+import { y as responseStatus } from "./chunk-github-api.mjs";
+import { a as renderHunks, i as parsePatch, n as newestWalkthrough, r as spaceHeadings } from "./chunk-generate.mjs";
+import { n as useSyncPullRequest } from "./chunk-react-surface.mjs";
+import { t as githubConnection } from "./chunk-pull-request2.mjs";
+import * as PreviewCapabilities from "@dxos/plugin-preview/PreviewCapabilities";
+import { meta } from "#meta";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { createBasicExtensions, createMarkdownExtensions, createThemeExtensions, decorateMarkdown, diffBlocks, scrollbarAutohide, walkthroughSidebar, walkthroughTheme } from "@dxos/ui-editor";
+import { GitHubOperation, Walkthrough } from "#types";
+import * as Effect from "effect/Effect";
+import { PullRequest } from "@dxos/types";
+import { Database, Filter, Obj, Ref } from "@dxos/echo";
+import * as Schema from "effect/Schema";
+import * as AppCapabilities from "@dxos/app-toolkit/AppCapabilities";
+import * as LayoutOperation from "@dxos/app-toolkit/LayoutOperation";
+import { log } from "@dxos/log";
+import * as Card from "@dxos/react-ui/Card";
+import * as Hooks from "@dxos/react-ui/Hooks";
+import * as Layout from "@dxos/react-ui/Layout";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useObject, useQuery } from "@dxos/echo-react";
+import * as Hooks$1 from "@dxos/app-framework/Hooks";
+import * as ToolkitHooks from "@dxos/app-toolkit/Hooks";
+import * as EffectEx from "@dxos/effect/EffectEx";
+import { Form } from "@dxos/react-ui-form";
+import * as Binding from "@dxos/plugin-connector/Binding";
+import { ProgressMeter } from "@dxos/react-ui-components";
+import { ActionToolbar, MenuBuilder, useMenuBuilder } from "@dxos/react-ui-menu";
+import * as Panel from "@dxos/react-ui/Panel";
+import * as Tabs from "@dxos/react-ui/Tabs";
+import * as Button from "@dxos/react-ui/Button";
+import * as Field from "@dxos/react-ui/Field";
+import * as Input from "@dxos/react-ui/Input";
+import * as Popover from "@dxos/react-ui/Popover";
+import * as VirtualAnchor from "@dxos/react-ui/VirtualAnchor";
+import { Listbox, Tree, createStaticTreeModel } from "@dxos/react-ui-list";
+import * as ScrollArea from "@dxos/react-ui/ScrollArea";
+import * as Status from "@dxos/react-ui/Status";
+import { TextEditor } from "@dxos/react-ui-editor";
+import { DxAnchor } from "@dxos/lit-ui/react";
+import { MarkdownLink, MarkdownView } from "@dxos/react-ui-markdown";
+import * as Icon from "@dxos/react-ui/Icon";
+import { Masonry } from "@dxos/react-ui-masonry";
+//#region src/components/PullRequestFiles/files.ts
+/** Id of the synthetic root the tree model anchors its top-level rows to; never rendered. */
+var FILE_TREE_ROOT = "root";
+/**
+* The changed files as a directory tree, directories before files and each alphabetical — the order
+* GitHub's own file tree uses. A directory whose only child is another directory is folded into one
+* row (`src/components`), since a chain of single-entry folders is depth without information.
+*/
+var buildFileTree = (files) => {
+	let count = 0;
+	const nextId = () => `node-${++count}`;
+	const root = {
+		id: FILE_TREE_ROOT,
+		path: "",
+		name: "",
+		children: [],
+		added: 0,
+		removed: 0
+	};
+	for (const file of files) {
+		const segments = file.path.split("/");
+		let parent = root;
+		for (let index = 0; index < segments.length - 1; index++) {
+			const path = segments.slice(0, index + 1).join("/");
+			let directory = parent.children.find((child) => !child.file && child.path === path);
+			if (!directory) {
+				directory = {
+					id: nextId(),
+					path,
+					name: segments[index],
+					children: [],
+					added: 0,
+					removed: 0
+				};
+				parent.children.push(directory);
+			}
+			parent = directory;
+		}
+		parent.children.push({
+			id: nextId(),
+			path: file.path,
+			name: segments.at(-1) ?? file.path,
+			file,
+			children: [],
+			added: file.added,
+			removed: file.removed
+		});
+	}
+	const finish = (node) => {
+		const children = node.children.map(finish).sort(compareNodes);
+		let folded = {
+			...node,
+			children,
+			added: node.file ? node.added : children.reduce((sum, child) => sum + child.added, 0),
+			removed: node.file ? node.removed : children.reduce((sum, child) => sum + child.removed, 0)
+		};
+		while (folded !== root && !folded.file && folded.children.length === 1 && !folded.children[0].file) {
+			const [only] = folded.children;
+			folded = {
+				...only,
+				name: `${folded.name}/${only.name}`
+			};
+		}
+		return folded;
+	};
+	return finish(root);
+};
+var compareNodes = (left, right) => Number(!!left.file) - Number(!!right.file) || left.name.localeCompare(right.name);
+/** The files in the order the tree lists them, which is the order previous/next walks. */
+var flattenFiles = (node) => node.file ? [node.file] : node.children.flatMap(flattenFiles);
+/**
+* One file's change as the ```diff fence the walkthrough renders, so the files view shows a file
+* exactly as a walkthrough chunk would. The fence is one backtick longer than any run in the body:
+* a context line of a markdown file can itself be a fence, which would otherwise close this one.
+*/
+var diffFence = (file) => {
+	const body = renderHunks(file.hunks);
+	const longest = Math.max(0, ...(body.match(/`+/g) ?? []).map((run) => run.length));
+	const fence = "`".repeat(Math.max(3, longest + 1));
+	return `${fence}diff file=${file.path}\n${body}\n${fence}`;
+};
+/**
+* A short digest of a file's change. A file is reviewed at a signature: when a push changes the
+* file its signature moves and the check falls away, as GitHub's "Viewed" does.
+*/
+var fileSignature = (file) => {
+	let hash = 2166136261;
+	for (const hunk of file.hunks) for (const line of [hunk.header, ...hunk.lines]) {
+		for (let index = 0; index < line.length; index++) {
+			hash ^= line.charCodeAt(index);
+			hash = Math.imul(hash, 16777619);
+		}
+		hash ^= 10;
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+};
+//#endregion
+//#region src/hooks/usePullRequestFiles.ts
+var __dxlog_file$2 = "/__w/dxos/dxos/packages/plugins/plugin-github/src/hooks/usePullRequestFiles.ts";
+var readRecord = (key) => {
+	try {
+		const value = localStorage.getItem(key);
+		return value ? JSON.parse(value) : {};
+	} catch (error) {
+		log.warn("reviewed files unreadable", { error }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 33,
+			S: void 0
+		});
+		return {};
+	}
+};
+var writeRecord = (key, record) => {
+	try {
+		localStorage.setItem(key, JSON.stringify(record));
+	} catch (error) {
+		log.warn("reviewed files not saved", { error }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 42,
+			S: void 0
+		});
+	}
+};
+/**
+* A pull request's changed files, the one on screen, and which the reader has reviewed.
+*
+* Reviewed state is the reader's own, so it lives in their browser under `storageKey` rather than in
+* the space. A file is reviewed at the change it had when checked: a push that changes it unchecks
+* it, as GitHub's "Viewed" does.
+*/
+var usePullRequestFiles = (diff, storageKey) => {
+	const files = useMemo(() => diff === void 0 ? [] : parsePatch(diff), [diff]);
+	const tree = useMemo(() => diff === void 0 ? void 0 : buildFileTree(files), [diff, files]);
+	const order = useMemo(() => tree ? flattenFiles(tree) : [], [tree]);
+	const signatures = useMemo(() => new Map(files.map((file) => [file.path, fileSignature(file)])), [files]);
+	const [record, setRecord] = useState(() => readRecord(storageKey));
+	useEffect(() => setRecord(readRecord(storageKey)), [storageKey]);
+	const reviewed = useMemo(() => new Set(Object.keys(record).filter((path) => signatures.get(path) === record[path])), [record, signatures]);
+	const setReviewed = useCallback((path, value) => {
+		setRecord((previous) => {
+			const next = { ...previous };
+			const signature = signatures.get(path);
+			if (value && signature) next[path] = signature;
+			else delete next[path];
+			writeRecord(storageKey, next);
+			return next;
+		});
+	}, [signatures, storageKey]);
+	const [selected, setSelected] = useState();
+	const file = order.find((candidate) => candidate.path === selected) ?? order[0];
+	return {
+		tree,
+		files,
+		file,
+		reviewed,
+		select: setSelected,
+		step: useCallback((delta) => {
+			const index = order.findIndex((candidate) => candidate.path === file?.path);
+			const next = order[index + delta];
+			if (next) setSelected(next.path);
+		}, [order, file]),
+		setReviewed
+	};
+};
+//#endregion
+//#region src/hooks/usePullRequestDiff.ts
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/plugins/plugin-github/src/hooks/usePullRequestDiff.ts";
+/** Reads a pull request's diff through the space's GitHub connection, once `enabled` first turns true. */
+var usePullRequestDiff = (pullRequest, spaceId, enabled) => {
+	const { invokePromise } = Hooks$1.useOperationInvoker();
+	const [result, setResult] = useState({});
+	const [requested, setRequested] = useState(false);
+	useEffect(() => {
+		if (enabled) setRequested(true);
+	}, [enabled]);
+	useEffect(() => {
+		if (!requested) return;
+		let cancelled = false;
+		invokePromise(GitHubOperation.GetPullRequestDiff, { pullRequest }, { spaceId }).then(({ data, error }) => {
+			if (cancelled) return;
+			if (error) log.warn("pull request diff failed", { error }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 47,
+				S: void 0
+			});
+			setResult({
+				diff: data?.diff,
+				commit: data?.commit,
+				error
+			});
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		requested,
+		invokePromise,
+		pullRequest,
+		spaceId
+	]);
+	return result;
+};
+//#endregion
+//#region src/components/CommentComposer/CommentComposer.tsx
+/**
+* The comment field, its target and its buttons — rendered as a band under the pull request header
+* when the comment is about the pull request, and inside {@link LineCommentPopover} when it is
+* about one line of a diff.
+*/
+var CommentComposer = ({ value, busy, target, onValueChange, onSubmit, onCancel }) => {
+	const { t } = Hooks.useTranslation(meta.profile.key);
+	const handleKeyDown = useCallback((event) => {
+		if (event.key === "Enter" && (event.metaKey || event.ctrlKey)) {
+			event.preventDefault();
+			if (!busy && value.trim()) onSubmit();
+		}
+	}, [
+		busy,
+		value,
+		onSubmit
+	]);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		target && /* @__PURE__ */ jsx("span", {
+			className: "text-sm text-fg-muted",
+			children: t("comment-line.label", {
+				file: target.file,
+				line: target.line
+			})
+		}),
+		/* @__PURE__ */ jsx(Field.Root, { children: /* @__PURE__ */ jsx(Input.Textarea, {
+			autoFocus: true,
+			rows: 4,
+			placeholder: t("comment-placeholder.label"),
+			value,
+			onChange: (event) => onValueChange(event.target.value),
+			onKeyDown: handleKeyDown
+		}) }),
+		/* @__PURE__ */ jsxs(Layout.Flex, {
+			justify: "end",
+			gap: "sm",
+			children: [/* @__PURE__ */ jsx(Button.Root, {
+				onClick: onCancel,
+				children: t("comment-cancel.label")
+			}), /* @__PURE__ */ jsx(Button.Root, {
+				variant: "primary",
+				disabled: busy || !value.trim(),
+				onClick: onSubmit,
+				children: t("comment-submit.label")
+			})]
+		})
+	] });
+};
+/** The composer as a band under the toolbar, for a comment on the pull request as a whole. */
+var CommentBand = (props) => /* @__PURE__ */ jsx(Layout.Flex, {
+	column: true,
+	gap: "sm",
+	classNames: "p-3 border-b border-separator",
+	children: /* @__PURE__ */ jsx(CommentComposer, { ...props })
+});
+/**
+* The composer floated at the diff line it addresses, so the reader reads the comment against the
+* code it is about rather than against a band at the other end of the document.
+*/
+var LineCommentPopover = ({ open, anchorRef, ...props }) => /* @__PURE__ */ jsx(Popover.Root, {
+	open,
+	onOpenChange: ({ open: next }) => {
+		if (!next) props.onCancel();
+	},
+	positioning: {
+		...VirtualAnchor.virtualAnchor(anchorRef),
+		placement: "bottom-start"
+	},
+	children: /* @__PURE__ */ jsx(Popover.Content, {
+		classNames: "w-[28rem] max-w-[90cqi]",
+		children: /* @__PURE__ */ jsx(Popover.Body, {
+			classNames: "flex flex-col gap-2 p-2",
+			children: /* @__PURE__ */ jsx(CommentComposer, { ...props })
+		})
+	})
+});
+//#endregion
+//#region src/components/PullRequestFiles/DiffStat.tsx
+/** `+12 -3`, coloured as the diff gutters are, with a zero count left out. */
+var DiffStat = ({ added, removed }) => /* @__PURE__ */ jsxs("span", {
+	className: "flex items-center gap-1 ps-2 text-xs tabular-nums whitespace-nowrap",
+	children: [added > 0 && /* @__PURE__ */ jsxs("span", {
+		className: "text-(--color-cm-diff-add-gutter)",
+		children: ["+", added]
+	}), removed > 0 && /* @__PURE__ */ jsxs("span", {
+		className: "text-(--color-cm-diff-remove-gutter)",
+		children: ["-", removed]
+	})]
+});
+//#endregion
+//#region src/components/PullRequestFiles/FileTree.tsx
+/**
+* The changed files as a tree: a checkbox per file to mark it reviewed, its change counts at the
+* trailing edge, and the file on screen as the current row.
+*/
+var FileTree = ({ root, selected, reviewed, onSelect, onReviewedChange }) => {
+	const { t } = Hooks.useTranslation(meta.profile.key);
+	const [closed, setClosed] = useState(() => /* @__PURE__ */ new Set());
+	const model = useMemo(() => createStaticTreeModel(root, {
+		getChildren: (node) => node.children,
+		getProps: (node) => ({
+			label: node.name,
+			count: void 0,
+			testId: "pull-request.files.row"
+		}),
+		isOpen: (node) => !closed.has(node.id),
+		isCurrent: (node) => node.file !== void 0 && node.path === selected
+	}), [
+		root,
+		selected,
+		closed
+	]);
+	const handleOpenChange = useCallback(({ item, open }) => setClosed((previous) => {
+		const next = new Set(previous);
+		if (open) next.delete(item.id);
+		else next.add(item.id);
+		return next;
+	}), []);
+	const handleSelect = useCallback(({ item }) => {
+		if (item.file) onSelect(item.path);
+	}, [onSelect]);
+	const renderRow = useCallback((node) => {
+		const item = node.item;
+		return /* @__PURE__ */ jsxs(Tree.Item, {
+			node,
+			children: [
+				/* @__PURE__ */ jsx(Tree.ItemIndicator, {}),
+				/* @__PURE__ */ jsx(Tree.ItemIcon, {
+					icon: item?.file ? void 0 : "ph--folder--regular",
+					children: item?.file && /* @__PURE__ */ jsx(Input.Checkbox, {
+						checked: reviewed.has(item.path),
+						onCheckedChange: ({ checked }) => onReviewedChange(item.path, checked === true),
+						onClick: (event) => event.stopPropagation(),
+						"aria-label": t("file-reviewed.label"),
+						"data-testid": "pull-request.files.reviewed"
+					})
+				}),
+				/* @__PURE__ */ jsx(Tree.ItemText, {}),
+				item && /* @__PURE__ */ jsx(DiffStat, {
+					added: item.added,
+					removed: item.removed
+				})
+			]
+		});
+	}, [
+		reviewed,
+		onReviewedChange,
+		t
+	]);
+	return /* @__PURE__ */ jsxs(Tree.Root, {
+		id: root.id,
+		model,
+		size: "sm",
+		onOpenChange: handleOpenChange,
+		onSelect: handleSelect,
+		children: [/* @__PURE__ */ jsx(Tree.Label, {
+			srOnly: true,
+			children: t("files-tree.label")
+		}), /* @__PURE__ */ jsx(Tree.Content, { children: renderRow })]
+	});
+};
+//#endregion
+//#region src/components/WalkthroughView/extensions.ts
+/** A definite content width, which the diff chunks cap themselves against. */
+var slots = { content: { className: "dx-container-type-inline-size w-full mx-auto! max-w-[min(72rem,100%-3rem)] py-3!" } };
+/**
+* A read-only markdown document whose ```diff fences render as diff chunks — the one reading surface
+* both a walkthrough and a single changed file are shown in, so the two cannot drift apart.
+*/
+var diffDocumentExtensions = ({ themeMode, sidebar = "none", layout, onLineComment }) => [
+	createThemeExtensions({
+		themeMode,
+		slots
+	}),
+	createBasicExtensions({
+		lineWrapping: true,
+		readOnly: true
+	}),
+	createMarkdownExtensions(),
+	decorateMarkdown(),
+	scrollbarAutohide(),
+	walkthroughTheme(),
+	diffBlocks({
+		layout,
+		...onLineComment ? { onLineComment } : {}
+	}),
+	sidebar === "none" ? [] : walkthroughSidebar({ variant: sidebar })
+];
+//#endregion
+//#region src/components/WalkthroughView/WalkthroughView.tsx
+/**
+* A read-only diff document: a whole walkthrough with its navigation rail, or one file's change as a
+* single fence. Either way the chunks are the walkthrough's own, so a file reads the same in both.
+*/
+var WalkthroughView = ({ value, sidebar, layout, onLineComment }) => {
+	const themeMode = Hooks.useThemeMode();
+	const extensions = useMemo(() => diffDocumentExtensions({
+		themeMode,
+		sidebar,
+		layout,
+		onLineComment
+	}), [
+		themeMode,
+		sidebar,
+		layout,
+		onLineComment
+	]);
+	const markdown = useMemo(() => spaceHeadings(value), [value]);
+	return /* @__PURE__ */ jsx(TextEditor, {
+		value: markdown,
+		extensions,
+		focusable: false,
+		classNames: "dx-expand overflow-hidden"
+	});
+};
+/** What the walkthrough tab shows before there is a walkthrough: the offer to write one, or its progress. */
+var WalkthroughPlaceholder = ({ generating, onGenerate }) => {
+	const { t } = Hooks.useTranslation(meta.profile.key);
+	return /* @__PURE__ */ jsxs(Layout.Flex, {
+		column: true,
+		center: true,
+		gap: "md",
+		classNames: "dx-expand",
+		children: [/* @__PURE__ */ jsx(Status.Empty, { children: t(generating ? "walkthrough-generating.message" : "no-walkthrough.message") }), !generating && /* @__PURE__ */ jsx(Button.Root, {
+			variant: "primary",
+			onClick: onGenerate,
+			children: t("generate-walkthrough.label")
+		})]
+	});
+};
+//#endregion
+//#region src/components/PullRequestFiles/PullRequestFiles.tsx
+/**
+* Every changed file, one at a time: the file's diff rendered as a walkthrough chunk, beside a rail
+* listing the changed files as a tree the reader checks off as they go.
+*/
+var PullRequestFiles = ({ tree, file, reviewed, total, error, onSelect, onReviewedChange, onLineComment }) => {
+	const { t } = Hooks.useTranslation(meta.profile.key);
+	const fence = useMemo(() => file && file.hunks.length > 0 ? diffFence(file) : void 0, [file]);
+	if (error) return /* @__PURE__ */ jsx(Status.Empty, {
+		icon: "ph--warning--regular",
+		classNames: "dx-expand",
+		children: error
+	});
+	if (!tree) return /* @__PURE__ */ jsx(Status.Empty, {
+		classNames: "dx-expand",
+		children: t("files-loading.message")
+	});
+	return /* @__PURE__ */ jsxs(Layout.Grid, {
+		grow: true,
+		cols: ["fill", "18rem"],
+		"data-testid": "pull-request.files",
+		children: [fence ? /* @__PURE__ */ jsx(WalkthroughView, {
+			value: fence,
+			onLineComment
+		}, file?.path) : /* @__PURE__ */ jsx(Status.Empty, {
+			classNames: "dx-expand",
+			children: t(file ? "file-no-diff.message" : "no-files.message")
+		}), /* @__PURE__ */ jsx(ScrollArea.Root, {
+			classNames: "border-s border-separator-subtle",
+			children: /* @__PURE__ */ jsxs(ScrollArea.Viewport, {
+				classNames: "p-2",
+				children: [/* @__PURE__ */ jsx(Field.Root, { children: /* @__PURE__ */ jsx(Field.Label, {
+					classNames: "px-2",
+					children: t("files-reviewed.label", {
+						reviewed: reviewed.size,
+						total
+					})
+				}) }), /* @__PURE__ */ jsx(FileTree, {
+					root: tree,
+					selected: file?.path,
+					reviewed,
+					onSelect,
+					onReviewedChange
+				})]
+			})
+		})]
+	});
+};
+//#endregion
+//#region src/components/PullRequestOverview/ArtifactPill.tsx
+/** The leading icon for each kind of artifact. */
+var artifactIcon = {
+	video: "ph--film-strip--regular",
+	image: "ph--image--regular",
+	file: "ph--file--regular"
+};
+/** The image or video itself, or nothing for a file the browser cannot show inline. */
+var ArtifactMedia = ({ artifact, classNames }) => artifact.kind === "video" ? /* @__PURE__ */ jsx("video", {
+	src: artifact.url,
+	controls: true,
+	muted: true,
+	playsInline: true,
+	preload: "metadata",
+	className: ["block w-full bg-black rounded-sm", classNames].filter(Boolean).join(" "),
+	"data-testid": "pull-request.artifact.video"
+}) : artifact.kind === "image" ? /* @__PURE__ */ jsx("img", {
+	src: artifact.url,
+	alt: artifact.label ?? artifact.name,
+	loading: "lazy",
+	className: ["block w-full object-contain rounded-sm", classNames].filter(Boolean).join(" "),
+	"data-testid": "pull-request.artifact.image"
+}) : null;
+/**
+* An artifact link as a pill that previews its image or video in place, so a reader sees the demo
+* without leaving the pull request. The outline matches the anchor chip a GitHub link becomes, so
+* the body's links read as one kind of thing.
+*/
+var ArtifactPill = ({ artifact, children }) => {
+	const label = typeof children === "string" && children !== artifact.url ? children : artifact.name;
+	if (artifact.kind === "file") return /* @__PURE__ */ jsx("a", {
+		href: artifact.url,
+		target: "_blank",
+		rel: "noopener noreferrer",
+		className: "dx-tag-anchor",
+		children: label
+	});
+	return /* @__PURE__ */ jsxs(Popover.Root, {
+		autoFocus: false,
+		children: [/* @__PURE__ */ jsx(Popover.Trigger, {
+			asChild: true,
+			children: /* @__PURE__ */ jsx(Button.Root, {
+				hue: "neutral",
+				size: "sm",
+				classNames: "bg-input-surface text-fg font-normal ring-inset ring ring-neutral-border hover:bg-hover-surface hover:ring-info-border align-baseline",
+				icon: artifactIcon[artifact.kind],
+				iconClassNames: artifact.kind === "video" ? "text-violet-text" : "text-sky-text",
+				label,
+				"data-testid": "pull-request.artifact.pill"
+			})
+		}), /* @__PURE__ */ jsx(Popover.Content, {
+			classNames: "w-[min(40rem,90vw)]",
+			children: /* @__PURE__ */ jsx(Popover.Body, {
+				classNames: "p-1",
+				children: /* @__PURE__ */ jsx(ArtifactMedia, { artifact })
+			})
+		})]
+	});
+};
+//#endregion
+//#region src/components/PullRequestOverview/CheckRunList.tsx
+var outcomeIcon = {
+	failure: {
+		icon: "ph--x-circle--fill",
+		classNames: "text-error-text"
+	},
+	pending: {
+		icon: "ph--circle-notch--regular",
+		classNames: "text-warning-text animate-spin"
+	},
+	success: {
+		icon: "ph--check-circle--fill",
+		classNames: "text-success-text"
+	},
+	neutral: {
+		icon: "ph--minus-circle--regular",
+		classNames: "text-fg-muted"
+	},
+	skipped: {
+		icon: "ph--prohibit--regular",
+		classNames: "text-fg-muted"
+	}
+};
+var outcomeOrder = [
+	"failure",
+	"pending",
+	"success",
+	"neutral",
+	"skipped"
+];
+/**
+* `4m 12s` from start to finish, or to `now` for a run still in progress;
+* undefined for a run that has not started, or has not finished when no `now` is given.
+*/
+var formatDuration = (startedAt, completedAt, now) => {
+	const end = completedAt ? Date.parse(completedAt) : now;
+	if (!startedAt || end === void 0) return;
+	const seconds = Math.max(0, Math.round((end - Date.parse(startedAt)) / 1e3));
+	if (Number.isNaN(seconds)) return;
+	const minutes = Math.floor(seconds / 60);
+	return minutes > 0 ? `${minutes}m ${seconds % 60}s` : `${seconds}s`;
+};
+/** The current time, re-rendering once a second while `active` so elapsed times stay current. */
+var useNow = (active) => {
+	const [now, setNow] = useState(() => Date.now());
+	useEffect(() => {
+		if (!active) return;
+		setNow(Date.now());
+		const interval = setInterval(() => setNow(Date.now()), 1e3);
+		return () => clearInterval(interval);
+	}, [active]);
+	return now;
+};
+/** Sorts runs by what needs attention, then by name so shards read in order. */
+var sortCheckRuns = (runs) => [...runs].sort((a, b) => outcomeOrder.indexOf(a.outcome) - outcomeOrder.indexOf(b.outcome) || a.name.localeCompare(b.name, void 0, { numeric: true }));
+/** Every check on the head commit: its outcome, how long it took, and its logs a click away. */
+var CheckRunList = ({ runs }) => {
+	const { t } = Hooks.useTranslation(meta.profile.key);
+	const sorted = useMemo(() => runs ? sortCheckRuns(runs) : void 0, [runs]);
+	const summary = useCheckSummary(runs);
+	const now = useNow(runs?.some((run) => run.outcome === "pending" && run.startedAt) ?? false);
+	if (!sorted || sorted.length === 0) return /* @__PURE__ */ jsx(Status.Empty, { children: t(sorted ? "no-checks.message" : "checks-loading.message") });
+	return /* @__PURE__ */ jsx(Listbox.Root, {
+		items: sorted.map((run) => ({
+			value: `${run.name}-${run.url ?? ""}`,
+			label: run.name
+		})),
+		children: /* @__PURE__ */ jsx(Listbox.Content, {
+			"aria-label": summary,
+			"data-testid": "pull-request.checks",
+			children: sorted.map((run) => {
+				const { icon, classNames } = outcomeIcon[run.outcome];
+				const duration = formatDuration(run.startedAt, run.completedAt, run.outcome === "pending" ? now : void 0);
+				const detail = run.conclusion && run.conclusion !== run.outcome && run.conclusion !== "failure" ? run.conclusion.replace(/_/g, " ") : void 0;
+				const outcome = run.outcome === "skipped" ? t("check-outcome.skipped.label") : run.outcome === "pending" ? [t("check-outcome.pending.label"), duration].filter(Boolean).join(" · ") : duration ?? t(`check-outcome.${run.outcome}.label`);
+				const url = run.url;
+				return /* @__PURE__ */ jsxs(Listbox.Item, {
+					id: `${run.name}-${url ?? ""}`,
+					"data-outcome": run.outcome,
+					"data-testid": "pull-request.check",
+					onClick: url ? () => window.open(url, "_blank", "noopener,noreferrer") : void 0,
+					children: [
+						/* @__PURE__ */ jsx(Listbox.ItemIcon, {
+							icon,
+							classNames
+						}),
+						/* @__PURE__ */ jsx(Listbox.ItemText, { children: run.name }),
+						/* @__PURE__ */ jsx(Listbox.ItemDescription, { children: [detail, outcome].filter(Boolean).join(" · ") })
+					]
+				}, `${run.name}-${url ?? ""}`);
+			})
+		})
+	});
+};
+/** The label the checks section carries: the counts once there are runs to count. */
+var useCheckSummary = (runs) => {
+	const { t } = Hooks.useTranslation(meta.profile.key);
+	return useMemo(() => {
+		if (!runs || runs.length === 0) return t("checks.label");
+		const counts = {
+			success: 0,
+			failure: 0,
+			pending: 0,
+			skipped: 0,
+			neutral: 0
+		};
+		for (const run of runs) counts[run.outcome]++;
+		return t("checks-summary.label", {
+			passed: counts.success + counts.neutral,
+			failed: counts.failure,
+			pending: counts.pending,
+			skipped: counts.skipped
+		});
+	}, [runs, t]);
+};
+//#endregion
+//#region src/components/PullRequestOverview/PullRequestDetails.tsx
+/** What the overview's details section shows, as a read-only form: one row per fact about the pull request. */
+var PullRequestDetailsSchema = Schema.Struct({
+	reference: Schema.String.annotate({ title: "Pull request" }),
+	state: Schema.optional(Schema.String.annotate({ title: "State" })),
+	checks: Schema.optional(Schema.String.annotate({ title: "Checks" })),
+	branches: Schema.optional(Schema.String.annotate({ title: "Branches" }))
+});
+var VIDEO_EXTENSIONS = [
+	"webm",
+	"mp4",
+	"mov",
+	"m4v",
+	"ogv"
+];
+var IMAGE_EXTENSIONS = [
+	"png",
+	"jpg",
+	"jpeg",
+	"gif",
+	"webp",
+	"svg",
+	"avif"
+];
+/** The artifact a URL names, or undefined when it is not in the artifacts bucket. */
+var parseArtifactLink = (url) => {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return;
+	}
+	if (parsed.protocol !== "https:" || parsed.hostname !== "pub-39066a86073446d7b77b1c157b660bb5.r2.dev") return;
+	const segment = parsed.pathname.split("/").at(-1) ?? "";
+	if (!segment) return;
+	const name = safeDecode(segment);
+	const extension = name.split(".").at(-1)?.toLowerCase() ?? "";
+	return {
+		url,
+		kind: VIDEO_EXTENSIONS.includes(extension) ? "video" : IMAGE_EXTENSIONS.includes(extension) ? "image" : "file",
+		name
+	};
+};
+var CLAUDE_SESSION = /https:\/\/claude\.ai\/code\/session_[A-Za-z0-9]+/;
+var PREVIEW_BLOCK = /<!--\s*composer-preview:begin\s*-->([\s\S]*?)<!--\s*composer-preview:end\s*-->/;
+var PREVIEW_LINE = /^\s*🚀\s*Composer preview:\s*(https?:\/\/\S+)\s*$/m;
+var FOOTER_LINES = [
+	/^\s*🤖\s*Generated with \[?Claude Code\]?(\([^)]*\))?\s*$/,
+	/^\s*_?Generated by \[Claude Code\]\([^)]*\)_?\s*$/,
+	new RegExp(`^\\s*<?${CLAUDE_SESSION.source}>?\\s*$`)
+];
+var MARKDOWN_LINK = /!?\[([^\]]*)\]\((https?:\/\/[^\s)]+)\)/g;
+var BARE_URL = /https?:\/\/[^\s)<>\]|]+/g;
+/**
+* Splits a pull request body into its prose and what the footers and links say.
+*
+* The footers are the harness's (`🤖 Generated with Claude Code` and the session URL) and CI's
+* (the Composer preview block); the article shows them as cards, so they are taken out of the prose
+* rather than rendered twice.
+*/
+var parsePullRequestBody = (body) => {
+	let text = (body ?? "").replace(/\r\n/g, "\n");
+	const sessionUrl = text.match(CLAUDE_SESSION)?.[0];
+	const hasClaudeFooter = FOOTER_LINES.slice(0, 2).some((pattern) => text.split("\n").some((line) => pattern.test(line)));
+	let previewUrl;
+	const block = text.match(PREVIEW_BLOCK);
+	if (block) {
+		previewUrl = block[1].match(PREVIEW_LINE)?.[1];
+		text = text.replace(PREVIEW_BLOCK, "");
+	}
+	const line = text.match(PREVIEW_LINE);
+	if (line) {
+		previewUrl ??= line[1];
+		text = text.replace(PREVIEW_LINE, "");
+	}
+	const lines = text.split("\n").filter((line) => !FOOTER_LINES.some((pattern) => pattern.test(line)));
+	while (lines.length > 0 && /^\s*(---+|\*\*\*+|___+)?\s*$/.test(lines[lines.length - 1])) lines.pop();
+	const markdown = lines.join("\n").trim();
+	return {
+		markdown,
+		...hasClaudeFooter || sessionUrl ? { claudeCode: sessionUrl ? { sessionUrl } : {} } : {},
+		...previewUrl ? { previewUrl } : {},
+		artifacts: findArtifacts(markdown)
+	};
+};
+/** Every artifact the prose links, in order of first mention. */
+var findArtifacts = (markdown) => {
+	const found = /* @__PURE__ */ new Map();
+	const add = (url, label) => {
+		const artifact = found.has(url) ? void 0 : parseArtifactLink(url);
+		if (artifact) found.set(url, {
+			...artifact,
+			...label && label !== url ? { label } : {}
+		});
+	};
+	for (const [, label, url] of markdown.matchAll(MARKDOWN_LINK)) add(url, label);
+	for (const [url] of markdown.replace(MARKDOWN_LINK, "").matchAll(BARE_URL)) add(url);
+	return [...found.values()].sort((a, b) => markdown.indexOf(a.url) - markdown.indexOf(b.url));
+};
+var safeDecode = (segment) => {
+	try {
+		return decodeURIComponent(segment);
+	} catch {
+		return segment;
+	}
+};
+//#endregion
+//#region src/components/PullRequestOverview/RelatedCards.tsx
+/** What {@link RelatedCards} would show; empty when the pull request links to nothing beyond its diff. */
+var useRelatedItems = ({ artifacts, claudeCode, previewUrl }) => {
+	const { t } = Hooks.useTranslation(meta.profile.key);
+	return useMemo(() => {
+		const items = artifacts.map((artifact) => ({
+			kind: "artifact",
+			id: artifact.url,
+			artifact
+		}));
+		if (previewUrl) items.push({
+			kind: "link",
+			id: "preview",
+			icon: "ph--rocket-launch--regular",
+			iconClassNames: "text-success-text",
+			title: t("preview-deployment.label"),
+			href: previewUrl,
+			detail: hostOf(previewUrl)
+		});
+		if (claudeCode) items.push({
+			kind: "link",
+			id: "claude",
+			icon: "px--anthropic--regular",
+			iconClassNames: "text-warning-text",
+			title: claudeCode.sessionUrl ? t("claude-session.label") : t("claude-generated.label"),
+			href: claudeCode.sessionUrl,
+			detail: claudeCode.sessionUrl?.split("/").at(-1)
+		});
+		return items;
+	}, [
+		artifacts,
+		claudeCode,
+		previewUrl,
+		t
+	]);
+};
+/**
+* What the pull request points at beyond its diff, one card each — its demo media, the preview
+* deployment built from it, and the session that wrote it — in the masonry grid related objects
+* use everywhere else. Renders inside its host's scroller rather than owning one.
+*/
+var RelatedCards = ({ items }) => /* @__PURE__ */ jsx(Masonry.Root, {
+	Tile: RelatedCard,
+	centered: false,
+	children: /* @__PURE__ */ jsx(Masonry.Viewport, {
+		items,
+		getId: (item) => item.id,
+		scroll: false
+	})
+});
+var RelatedCard = ({ data: item }) => {
+	const { t } = Hooks.useTranslation(meta.profile.key);
+	if (item.kind === "link") return /* @__PURE__ */ jsxs(Card.Root, {
+		"data-testid": `pull-request.related.${item.id}`,
+		children: [/* @__PURE__ */ jsx(CardHeading, {
+			icon: item.icon,
+			iconClassNames: item.iconClassNames,
+			title: item.title,
+			href: item.href
+		}), item.detail && /* @__PURE__ */ jsx(Card.Row, { children: /* @__PURE__ */ jsx(Card.Text, {
+			variant: "muted",
+			truncate: true,
+			children: item.detail
+		}) })]
+	});
+	const { artifact } = item;
+	return /* @__PURE__ */ jsxs(Card.Root, {
+		"data-testid": "pull-request.related.artifact",
+		children: [
+			/* @__PURE__ */ jsx(CardHeading, {
+				icon: artifactIcon[artifact.kind],
+				title: artifact.label ?? t(`artifact-${artifact.kind}.label`),
+				href: artifact.url
+			}),
+			/* @__PURE__ */ jsx(Card.Row, { children: /* @__PURE__ */ jsx(Card.Text, {
+				variant: "muted",
+				truncate: true,
+				children: artifact.name
+			}) }),
+			artifact.kind !== "file" && /* @__PURE__ */ jsx(Card.Body, { children: /* @__PURE__ */ jsx(ArtifactMedia, {
+				artifact,
+				classNames: "col-span-3 aspect-video max-h-[200px] object-cover"
+			}) })
+		]
+	});
+};
+var CardHeading = ({ icon, iconClassNames, title, href }) => {
+	const { t } = Hooks.useTranslation(meta.profile.key);
+	return /* @__PURE__ */ jsxs(Card.Header, { children: [
+		/* @__PURE__ */ jsx(Layout.Block, { children: /* @__PURE__ */ jsx(Icon.Icon, {
+			icon,
+			classNames: iconClassNames
+		}) }),
+		/* @__PURE__ */ jsx(Card.Title, { children: title }),
+		href && /* @__PURE__ */ jsx(Layout.Block, {
+			rail: "end",
+			children: /* @__PURE__ */ jsx(Button.Root, {
+				iconOnly: true,
+				variant: "ghost",
+				icon: "ph--arrow-square-out--regular",
+				label: t("open-link.label"),
+				onClick: () => window.open(href, "_blank", "noopener,noreferrer")
+			})
+		})
+	] });
+};
+var hostOf = (url) => {
+	try {
+		return new URL(url).host;
+	} catch {
+		return url;
+	}
+};
+//#endregion
+//#region src/components/PullRequestOverview/PullRequestOverview.tsx
+/**
+* A pull request as its author presented it: the description, the facts about it, what it links to
+* beyond the diff, and every check on its head commit.
+*/
+var PullRequestOverview = ({ body, details, runs }) => {
+	const { t } = Hooks.useTranslation(meta.profile.key);
+	const parsed = useMemo(() => parsePullRequestBody(body), [body]);
+	const components = useBodyComponents();
+	const related = useRelatedItems(parsed);
+	const checkSummary = useCheckSummary(runs);
+	return /* @__PURE__ */ jsx(Form.Root, {
+		schema: PullRequestDetailsSchema,
+		values: details,
+		layout: "static",
+		readonly: true,
+		children: /* @__PURE__ */ jsx(Form.Viewport, {
+			scroll: true,
+			width: "document",
+			children: /* @__PURE__ */ jsxs(Form.Content, { children: [
+				parsed.markdown ? /* @__PURE__ */ jsx(MarkdownView, {
+					content: parsed.markdown,
+					components,
+					"data-testid": "pull-request.body"
+				}) : /* @__PURE__ */ jsx(Status.Empty, { children: t("no-description.message") }),
+				/* @__PURE__ */ jsx(Form.FieldSet, {
+					label: t("details.label"),
+					"data-testid": "pull-request.details",
+					children: /* @__PURE__ */ jsx(Form.Fields, {})
+				}),
+				related.length > 0 && /* @__PURE__ */ jsx(Form.FieldSet, {
+					label: t("related.label"),
+					children: /* @__PURE__ */ jsx(RelatedCards, { items: related })
+				}),
+				/* @__PURE__ */ jsx(Form.FieldSet, {
+					label: checkSummary,
+					children: /* @__PURE__ */ jsx(CheckRunList, { runs })
+				})
+			] })
+		})
+	});
+};
+/**
+* Links in the body as pills: an artifact previews its media in place, and a link a preview
+* resolver answers (another pull request, an issue) becomes the anchor chip the editor makes of it.
+*/
+var useBodyComponents = () => {
+	const resolvers = Hooks$1.useCapabilities(PreviewCapabilities.LinkResolver);
+	return useMemo(() => ({ a: ({ children, href, node: _node, ...props }) => {
+		const artifact = href ? parseArtifactLink(href) : void 0;
+		if (artifact) return /* @__PURE__ */ jsx(ArtifactPill, {
+			artifact,
+			children
+		});
+		const all = resolvers.flat();
+		if (!href || !PreviewCapabilities.isPreviewLink(all, href)) return /* @__PURE__ */ jsx(MarkdownLink, {
+			href,
+			...props,
+			children
+		});
+		const icon = PreviewCapabilities.linkIcon(all, href);
+		return /* @__PURE__ */ jsxs(DxAnchor, {
+			eid: href,
+			className: "dx-tag-anchor",
+			children: [icon && /* @__PURE__ */ jsx(Icon.Icon, {
+				icon: icon.icon,
+				size: "md",
+				classNames: ["inline-block align-[-0.125em] me-1", icon.classNames]
+			}), children === href ? PreviewCapabilities.linkLabel(all, href) ?? children : children]
+		});
+	} }), [resolvers]);
+};
+//#endregion
+//#region src/components/PullRequestStatus/PullRequestStatus.tsx
+var stateHue = {
+	open: "green",
+	closed: "red",
+	merged: "purple",
+	draft: "neutral"
+};
+var reviewHue = {
+	approved: "green",
+	changes_requested: "red",
+	none: "neutral"
+};
+var ciHue = {
+	success: "green",
+	failure: "red",
+	pending: "amber",
+	none: "neutral"
+};
+/** One line answering where the pull request stands: open or merged, approved or not, CI green or red. */
+var PullRequestStatus = ({ reference, title, state, review, ci }) => {
+	const { t } = Hooks.useTranslation(meta.profile.key);
+	return /* @__PURE__ */ jsxs(Layout.Flex, {
+		align: "center",
+		gap: "sm",
+		role: "status",
+		classNames: "px-3 py-1.5 border-b border-separator-subtle text-sm min-w-0",
+		"data-testid": "pull-request.status",
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				className: "dx-tag dx-tag-inline shrink-0",
+				"data-hue": "neutral",
+				children: reference
+			}),
+			title && /* @__PURE__ */ jsx("span", {
+				className: "truncate grow",
+				children: title
+			}),
+			/* @__PURE__ */ jsxs(Layout.Flex, {
+				align: "center",
+				gap: "sm",
+				classNames: "shrink-0 ml-auto",
+				children: [
+					state && /* @__PURE__ */ jsx("span", {
+						className: "dx-tag dx-tag-inline",
+						"data-hue": stateHue[state],
+						"data-testid": "pull-request.status.state",
+						children: t(`pull-request-state.${state}.label`)
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "dx-tag dx-tag-inline",
+						"data-hue": review ? reviewHue[review.state] : "neutral",
+						"data-testid": "pull-request.status.review",
+						children: review ? t(`review-status.${review.state}.label`, { count: review.approvals }) : t("review-status.unknown.label")
+					}),
+					/* @__PURE__ */ jsxs("span", {
+						className: "dx-tag dx-tag-inline",
+						"data-hue": ci ? ciHue[ci.state] : "neutral",
+						"data-testid": "pull-request.status.ci",
+						children: [ci ? t(`ci-status.${ci.state}.label`) : t("ci-status.unknown.label"), ci && ci.checks.total > 0 && ` ${ci.checks.passed}/${ci.checks.total}`]
+					})
+				]
+			})
+		]
+	});
+};
+//#endregion
+//#region src/containers/PullRequestArticle/failure.ts
+/**
+* Names a pull-request action's failure so the user knows what to do about it.
+*
+* A rejected credential is the one failure the user can fix themselves, and it is indistinguishable
+* from any other error once it reaches the toast as `error.message` — GitHub answers it as a bare
+* `401`, which surfaces as `StatusCode: non 2xx status code (401 GET …)`. Matches the same
+* distinction `ImportPullRequestDialog` already draws on `tokenStatus`.
+*/
+var pullRequestFailureKey = (error, fallbackKey) => responseStatus(error) === 401 ? "github-token-rejected.title" : fallbackKey;
+//#endregion
+//#region src/containers/PullRequestArticle/PullRequestArticle.tsx
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-github/src/containers/PullRequestArticle/PullRequestArticle.tsx";
+var ciLabel = {
+	success: "ci-status.success.label",
+	failure: "ci-status.failure.label",
+	pending: "ci-status.pending.label",
+	none: "ci-status.none.label"
+};
+var TABS = [
+	"overview",
+	"walkthrough",
+	"files"
+];
+/**
+* A pull request read as a review: its number, state and CI outcome above whatever narration the
+* space holds, with approving and commenting one click away. Everything GitHub-side goes through
+* the space's GitHub connection.
+*
+* The pull request is the subject rather than the walkthrough because one exists before the other
+* does: a pull request just imported has no narration yet, and generating it is an action ON the
+* pull request, not a different object to open.
+*/
+var PullRequestArticle = ({ role, attendableId, subject: pullRequest }) => {
+	const { t } = Hooks.useTranslation(meta.profile.key);
+	const { invokePromise } = Hooks$1.useOperationInvoker();
+	const [subject] = useObject(pullRequest);
+	const db = Obj.getDatabase(pullRequest);
+	const spaceId = db?.spaceId;
+	const walkthroughs = useQuery(db, Filter.type(Walkthrough.Walkthrough, { pullRequest: Ref.make(pullRequest) }));
+	const walkthrough = useMemo(() => newestWalkthrough(walkthroughs), [walkthroughs]);
+	const walkthroughProgress = ToolkitHooks.useProgressMonitor(GitHubOperation.createWalkthroughProgressKey(pullRequest));
+	const progressRegistry = Hooks$1.useOptionalCapability(AppCapabilities.ProgressRegistry);
+	const [status, setStatus] = useState();
+	const state = status?.state ?? subject.state;
+	const [tab, setTab] = useState("overview");
+	const [busy, setBusy] = useState(false);
+	const [generating, setGenerating] = useState(false);
+	const [composing, setComposing] = useState(false);
+	const [comment, setComment] = useState("");
+	const [lineTarget, setLineTarget] = useState();
+	const lineAnchorRef = useRef(null);
+	const openLineComment = useCallback((target, anchor, commit) => {
+		lineAnchorRef.current = anchor;
+		setLineTarget({
+			target,
+			commit
+		});
+		setComposing(true);
+	}, []);
+	const handleWalkthroughLineComment = useCallback((target, anchor) => walkthrough && openLineComment(target, anchor, walkthrough.commit), [walkthrough, openLineComment]);
+	/** The toolbar's composer is about the pull request, so it drops whatever line was targeted. */
+	const handleToggleComposer = useCallback(() => {
+		setLineTarget(void 0);
+		lineAnchorRef.current = null;
+		setComposing((value) => value === false || lineTarget !== void 0);
+	}, [lineTarget]);
+	const handleCloseComposer = useCallback(() => {
+		setComposing(false);
+		setLineTarget(void 0);
+		lineAnchorRef.current = null;
+	}, []);
+	const pullRequestRef = useMemo(() => Ref.make(pullRequest), [pullRequest]);
+	const reference = PullRequest.reference(pullRequest);
+	const diff = usePullRequestDiff(pullRequestRef, spaceId, tab === "files");
+	const files = usePullRequestFiles(diff.diff, `${meta.profile.key}.reviewed.${reference}`);
+	const { file, step, setReviewed } = files;
+	const handleFilesLineComment = useCallback((target, anchor) => diff.commit && openLineComment(target, anchor, diff.commit), [diff.commit, openLineComment]);
+	/** Checking a file off moves on to the next one, the way a reader works down the list. */
+	const handleToggleReviewed = useCallback(() => {
+		if (!file) return;
+		const reviewed = !files.reviewed.has(file.path);
+		setReviewed(file.path, reviewed);
+		if (reviewed) step(1);
+	}, [
+		file,
+		files.reviewed,
+		setReviewed,
+		step
+	]);
+	const refreshStatus = useCallback(async () => {
+		const { data, error } = await invokePromise(GitHubOperation.GetPullRequestStatus, { pullRequest: pullRequestRef }, { spaceId });
+		if (error) {
+			log.warn("pull request status failed", { error }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 167,
+				S: void 0
+			});
+			return;
+		}
+		if (data) setStatus({
+			state: data.state,
+			body: data.body,
+			ci: data.ci,
+			checks: data.checks,
+			runs: data.runs,
+			review: data.review,
+			approvals: data.approvals
+		});
+	}, [
+		invokePromise,
+		pullRequestRef,
+		spaceId
+	]);
+	useEffect(() => {
+		refreshStatus();
+	}, [refreshStatus]);
+	useSyncPullRequest(pullRequest);
+	const toast = useCallback((id, title, success, description) => invokePromise(LayoutOperation.AddToast, {
+		id: `${meta.profile.key}.${id}`,
+		icon: success ? "ph--check-circle--regular" : "ph--warning--regular",
+		title: [title, { ns: meta.profile.key }],
+		...description ? { description } : {}
+	}), [invokePromise]);
+	/**
+	* A rejected credential is the one failure the user can fix, so it names the fix and links to the
+	* connection; any other failure shows the raw error under the action's own title.
+	*/
+	const failureToast = useCallback(async (id, fallbackKey, error) => {
+		const key = pullRequestFailureKey(error, fallbackKey);
+		if (key === fallbackKey || !db) return toast(id, key, false, error.message);
+		const connection = (await EffectEx.runPromise(githubConnection().pipe(Effect.provide(Database.layer(db)), Effect.orElseSucceed(() => void 0))))?.connection;
+		return invokePromise(LayoutOperation.AddToast, {
+			id: `${meta.profile.key}.${id}`,
+			icon: "ph--warning--regular",
+			title: [key, { ns: meta.profile.key }],
+			...connection ? {
+				actionLabel: ["open-github-connection.label", { ns: meta.profile.key }],
+				actionAlt: ["open-github-connection.label", { ns: meta.profile.key }],
+				onAction: () => void invokePromise(LayoutOperation.Open, {
+					subject: [Binding.connectionSubject(db.spaceId, connection.id)],
+					navigation: "immediate"
+				})
+			} : {}
+		});
+	}, [
+		db,
+		invokePromise,
+		toast
+	]);
+	const handleApprove = useCallback(async () => {
+		setBusy(true);
+		const { data, error } = await invokePromise(GitHubOperation.SubmitPullRequestApproval, { pullRequest: pullRequestRef }, { spaceId });
+		setBusy(false);
+		if (error) {
+			log.warn("approve failed", { error }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 248,
+				S: void 0
+			});
+			await failureToast("approve", "approve-pull-request-error.title", error);
+			return;
+		}
+		await toast("approve", data?.commented ? "approve-pull-request-commented.title" : "approve-pull-request-success.title", true);
+		refreshStatus();
+	}, [
+		invokePromise,
+		pullRequestRef,
+		spaceId,
+		toast,
+		failureToast,
+		refreshStatus
+	]);
+	/** `force` is what makes the toolbar's entry a REgeneration: the same head would otherwise no-op. */
+	const handleGenerate = useCallback(async () => {
+		setTab("walkthrough");
+		setGenerating(true);
+		const { error } = await invokePromise(GitHubOperation.GenerateWalkthrough, {
+			pullRequest: pullRequestRef,
+			force: walkthrough !== void 0
+		}, { spaceId });
+		setGenerating(false);
+		if (error) {
+			log.warn("walkthrough generation failed", { error }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 272,
+				S: void 0
+			});
+			await failureToast("walkthrough", "walkthrough-failed.title", error);
+			return;
+		}
+		await toast("walkthrough", "walkthrough-ready.title", true);
+	}, [
+		invokePromise,
+		pullRequestRef,
+		spaceId,
+		walkthrough,
+		toast,
+		failureToast
+	]);
+	const handleCopyLink = useCallback(async () => {
+		if (!subject.url) return;
+		try {
+			await navigator.clipboard.writeText(subject.url);
+		} catch (error) {
+			log.warn("copy link failed", { error }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 289,
+				S: void 0
+			});
+			await toast("copy-link", "copy-link-error.title", false);
+			return;
+		}
+		await toast("copy-link", "copy-link-success.title", true);
+	}, [subject.url, toast]);
+	const handleComment = useCallback(async () => {
+		const text = comment.trim();
+		if (!text) return;
+		setBusy(true);
+		const { error } = lineTarget ? await invokePromise(GitHubOperation.AddPullRequestReviewComment, {
+			pullRequest: pullRequestRef,
+			body: text,
+			commit: lineTarget.commit,
+			path: lineTarget.target.file,
+			line: lineTarget.target.line,
+			side: lineTarget.target.side === "before" ? "LEFT" : "RIGHT"
+		}, { spaceId }) : await invokePromise(GitHubOperation.AddPullRequestComment, {
+			pullRequest: pullRequestRef,
+			body: text
+		}, { spaceId });
+		setBusy(false);
+		if (error) {
+			log.warn("comment failed", { error }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 322,
+				S: void 0
+			});
+			await failureToast("comment", "comment-error.title", error);
+			return;
+		}
+		setComment("");
+		handleCloseComposer();
+		await toast("comment", "comment-success.title", true);
+	}, [
+		comment,
+		lineTarget,
+		invokePromise,
+		pullRequestRef,
+		spaceId,
+		toast,
+		failureToast,
+		handleCloseComposer
+	]);
+	const tabs = useMemo(() => /* @__PURE__ */ jsx(Tabs.List, { children: TABS.map((value) => /* @__PURE__ */ jsx(Tabs.Trigger, {
+		value,
+		"data-testid": `pull-request.tab.${value}`,
+		children: t(`${value}-tab.label`)
+	}, value)) }), [t]);
+	const fileReviewed = file !== void 0 && files.reviewed.has(file.path);
+	const menuActions = useMenuBuilder(() => {
+		const builder = MenuBuilder.make().action("tabs", {
+			variant: "custom",
+			label: ["views.label", { ns: meta.profile.key }],
+			render: () => tabs
+		}, () => {}).separator();
+		if (tab === "files") builder.action("previousFile", {
+			label: ["previous-file.label", { ns: meta.profile.key }],
+			icon: "ph--caret-up--regular",
+			disabled: !file,
+			disposition: "toolbar",
+			testId: "pull-request.toolbar.previous-file"
+		}, () => step(-1)).action("nextFile", {
+			label: ["next-file.label", { ns: meta.profile.key }],
+			icon: "ph--caret-down--regular",
+			disabled: !file,
+			disposition: "toolbar",
+			testId: "pull-request.toolbar.next-file"
+		}, () => step(1)).action("reviewed", {
+			label: ["file-reviewed.label", { ns: meta.profile.key }],
+			icon: fileReviewed ? "ph--check-square--fill" : "ph--square--regular",
+			iconOnly: false,
+			disabled: !file,
+			disposition: "toolbar",
+			testId: "pull-request.toolbar.reviewed"
+		}, () => handleToggleReviewed()).separator("line");
+		return builder.action("approve", {
+			label: ["approve-pull-request.label", { ns: meta.profile.key }],
+			icon: "ph--check-circle--regular",
+			variant: "primary",
+			iconOnly: false,
+			disabled: busy || state === "merged" || state === "closed",
+			disposition: "toolbar",
+			testId: "pull-request.toolbar.approve"
+		}, () => void handleApprove()).action("comment", {
+			label: ["comment-pull-request.label", { ns: meta.profile.key }],
+			icon: "ph--chat-text--regular",
+			disabled: busy,
+			disposition: "toolbar",
+			testId: "pull-request.toolbar.comment"
+		}, () => handleToggleComposer()).separator("line").action("generateWalkthrough", {
+			label: [walkthrough ? "regenerate-walkthrough.label" : "generate-walkthrough.label", { ns: meta.profile.key }],
+			icon: "ph--path--regular",
+			disabled: generating,
+			disposition: "toolbar",
+			testId: "pull-request.toolbar.generate-walkthrough"
+		}, () => void handleGenerate()).action("openOnGitHub", {
+			label: ["open-on-github.label", { ns: meta.profile.key }],
+			icon: "ph--arrow-square-out--regular",
+			disabled: !subject.url,
+			disposition: "toolbar",
+			testId: "pull-request.toolbar.open-on-github"
+		}, () => subject.url && window.open(subject.url, "_blank", "noopener,noreferrer")).action("copyLink", {
+			label: ["copy-link.label", { ns: meta.profile.key }],
+			icon: "ph--link--regular",
+			disabled: !subject.url,
+			disposition: "toolbar",
+			testId: "pull-request.toolbar.copy-link"
+		}, () => void handleCopyLink()).build();
+	}, [
+		tabs,
+		tab,
+		file,
+		fileReviewed,
+		step,
+		handleToggleReviewed,
+		busy,
+		generating,
+		walkthrough,
+		subject.url,
+		state,
+		handleApprove,
+		handleGenerate,
+		handleCopyLink,
+		handleToggleComposer
+	]);
+	const details = useMemo(() => ({
+		reference,
+		state,
+		checks: status ? `${t(ciLabel[status.ci])}${status.checks.total > 0 ? ` ${status.checks.passed}/${status.checks.total}` : ""}` : t("ci-status.unknown.label"),
+		branches: subject.headBranch && (subject.baseBranch ? `${subject.headBranch} → ${subject.baseBranch}` : subject.headBranch)
+	}), [
+		reference,
+		state,
+		status,
+		subject.headBranch,
+		subject.baseBranch,
+		t
+	]);
+	const composerProps = {
+		value: comment,
+		busy,
+		onValueChange: setComment,
+		onSubmit: () => void handleComment(),
+		onCancel: handleCloseComposer
+	};
+	return /* @__PURE__ */ jsx(Tabs.Root, {
+		asChild: true,
+		orientation: "horizontal",
+		value: tab,
+		onValueChange: (value) => setTab(TABS.find((candidate) => candidate === value) ?? "overview"),
+		children: /* @__PURE__ */ jsxs(Panel.Root, {
+			role,
+			children: [
+				/* @__PURE__ */ jsx(Panel.Header, { children: /* @__PURE__ */ jsx(ActionToolbar, {
+					...menuActions,
+					attendableId,
+					alwaysActive: true
+				}) }),
+				/* @__PURE__ */ jsx(Panel.Body, {
+					asChild: true,
+					children: /* @__PURE__ */ jsxs(Layout.Flex, {
+						column: true,
+						children: [
+							/* @__PURE__ */ jsx(PullRequestStatus, {
+								reference,
+								title: subject.title,
+								state,
+								review: status && {
+									state: status.review,
+									approvals: status.approvals
+								},
+								ci: status && {
+									state: status.ci,
+									checks: status.checks
+								}
+							}),
+							composing && !lineTarget && /* @__PURE__ */ jsx(CommentBand, { ...composerProps }),
+							/* @__PURE__ */ jsx(LineCommentPopover, {
+								...composerProps,
+								open: composing && !!lineTarget,
+								anchorRef: lineAnchorRef,
+								target: lineTarget?.target
+							}),
+							tab === "overview" && /* @__PURE__ */ jsx(PullRequestOverview, {
+								body: status?.body ?? subject.description,
+								details,
+								runs: status?.runs
+							}),
+							tab === "walkthrough" && (walkthrough ? /* @__PURE__ */ jsx(WalkthroughView, {
+								value: walkthrough.body,
+								sidebar: "full",
+								onLineComment: handleWalkthroughLineComment
+							}) : /* @__PURE__ */ jsx(WalkthroughPlaceholder, {
+								generating,
+								onGenerate: () => void handleGenerate()
+							})),
+							tab === "files" && /* @__PURE__ */ jsx(PullRequestFiles, {
+								tree: files.tree,
+								file,
+								reviewed: files.reviewed,
+								total: files.files.length,
+								error: diff.error && t("files-error.message"),
+								onSelect: files.select,
+								onReviewedChange: setReviewed,
+								onLineComment: diff.commit ? handleFilesLineComment : void 0
+							})
+						]
+					})
+				}),
+				/* @__PURE__ */ jsx(Panel.Footer, {
+					classNames: "border-t border-separator-subtle",
+					children: /* @__PURE__ */ jsx(ProgressMeter, {
+						state: walkthroughProgress?.status === "running" || walkthroughProgress?.status === "error" ? walkthroughProgress : void 0,
+						onCancel: progressRegistry && walkthroughProgress ? () => progressRegistry.cancel(walkthroughProgress.name) : void 0
+					})
+				})
+			]
+		})
+	});
+};
+//#endregion
+export { PullRequestArticle as t };
+
+//# sourceMappingURL=chunk-PullRequestArticle.mjs.map