@kubohiroya/turbowarp-plus-editor-git 0.16.1 → 0.17.0

package/dist/project-source-diff.js

@@ -1,4 +1,5 @@
-import { S as createProjectSourceDiff, _ as usePreviewSync, a as openProjectSourceTabs, c as gitHubRepositoryFromOrigin, d as assetFileName, f as organizeProjectChanges, g as createPreviewSync, h as BlockPreview, i as createScratchBlocksDiffLocator, l as ProjectSourceComparison, m as compareProjectForReview, n as openProjectComparison, p as projectPropertyLabel, r as createScratchBlocksDiffRenderer, s as createGitHubPullRequests, t as ProjectComparisonDialog, u as ProjectSourceReview, v as currentCostume, w as readProjectSourceDiff, x as compareProjectBlocks } from "./project-comparison-1rggIJse.js";
+import { a as compareProjectBlocks, o as createProjectSourceDiff, u as readProjectSourceDiff } from "./project-asset-paths-nL5sV35A.js";
+import { _ as usePreviewSync, a as openProjectSourceTabs, c as gitHubRepositoryFromOrigin, d as assetFileName, f as organizeProjectChanges, g as createPreviewSync, h as BlockPreview, i as createScratchBlocksDiffLocator, l as ProjectSourceComparison, m as compareProjectForReview, n as openProjectComparison, p as projectPropertyLabel, r as createScratchBlocksDiffRenderer, s as createGitHubPullRequests, t as ProjectComparisonDialog, u as ProjectSourceReview, v as currentCostume } from "./project-comparison-DjMlwyp8.js";
 import { n as init_objectSpread2, t as _objectSpread2 } from "./objectSpread2-Dkd68nJH.js";
 import React, { useEffect, useMemo, useRef, useState } from "react";
 // src/project-source-diff.tsx

package/dist/pull-request-panel.d.ts

@@ -3,11 +3,35 @@ import type { ProjectBlockRenderer } from './scratch-block-diff-renderer.js';
 import type { Repository } from './repository.js';
 import type { ProjectBlockLocator } from './block-diff-location.js';
 import type { ProjectSourceTabsFile } from './project-source-tabs.js';
+import type { GetRemoteSession } from './remote-operations.js';
 type OpenTabs = (key: string, files: readonly ProjectSourceTabsFile[], rememberAs?: string) => number;
-export declare function PullRequestReviewPanel({ repository, locale, renderBlock, locateFor, openTabs }: {
+/**
+ * Opens a pull request version fetched over the connection in the work tree: the host creates (or reuses) the local
+ * branch `pullRequestBranch(number)` at `head` and switches to it. `busy` disables the button.
+ */
+export interface PullRequestOpenLocally {
+    open(number: number, head: string): unknown;
+    busy: boolean;
+}
+/** The person's GitHub connection: while it is connected, pull request contents are read over Git Smart HTTP. */
+export interface PullRequestConnection {
+    getSession: GetRemoteSession;
+    connected(): boolean;
+}
+export declare function PullRequestReviewPanel({ repository, locale, renderBlock, locateFor, openTabs, connection, openLocally }: {
     repository: Repository;
     locale: string;
     renderBlock: ProjectBlockRenderer;
+    /**
+     * While connected, pull request contents are fetched over Git Smart HTTP (`refs/pull/<number>/head`) and compared
+     * from local Git objects, so private repositories can be reviewed. Without it, the public GitHub API is read.
+     */
+    connection?: PullRequestConnection;
+    /**
+     * Offers to open a pull request read over the connection in the work tree, on the branch `pr/<number>`. Pull
+     * requests read from the public API have no local objects, so the button is not shown for them.
+     */
+    openLocally?: PullRequestOpenLocally;
     /** Opens a pull request's project changes as tabs of the host's layout. */
     openTabs?: OpenTabs;
     /** Returns a locator for a project file whose PR head matches the open project, or `undefined`. */

package/dist/remote-operations.d.ts

@@ -2,4 +2,27 @@ import type { GitSmartHttpOptions } from './smart-http.js';
 export type RemoteOperation = 'fetch' | 'pull' | 'push';
 export type RemoteSession = NonNullable<Awaited<ReturnType<GitSmartHttpOptions['getSession']>>>;
 export type GetRemoteSession = (remote: string, write: boolean) => Promise<RemoteSession | null>;
+/**
+ * Where a fetched pull request head is kept: outside `refs/heads`, `refs/remotes` and `refs/tags`, so Git CLI lists it
+ * with `git for-each-ref refs/pull` and `git log --all` but not as a branch or tag, `git fetch --prune` leaves it alone,
+ * and `git gc` keeps its objects. Each fetch of the same pull request replaces it.
+ */
+export declare const pullRequestRef: (number: number) => string;
+export interface PullRequestFetch {
+    readonly number: number;
+    /** The commit at GitHub's `refs/pull/<number>/head`, kept locally at `ref`. */
+    readonly head: string;
+    readonly ref: string;
+    /** GitHub's default branch, from the advertised `HEAD`, or `null` when it is not advertised. */
+    readonly defaultBranch: string | null;
+    /** The branches on GitHub, as `refs/remotes/origin/<name>` after this fetch. */
+    readonly branches: readonly string[];
+}
+/**
+ * Fetches GitHub's `refs/pull/<number>/head` together with every branch, over the connection's Git Smart HTTP, like
+ * `git fetch origin refs/pull/<number>/head`. The branches update `refs/remotes/origin/*` as fetch does, and the head
+ * is kept at `pullRequestRef(number)`. The work tree, the index, HEAD and `.git/config` are never written. The writes
+ * are staged first and applied together, under the same lock as fetch, pull and push.
+ */
+export declare function runPullRequestFetch(root: FileSystemDirectoryHandle, number: number, getSession: GetRemoteSession, guard: () => void, signal?: AbortSignal): Promise<PullRequestFetch>;
 export declare function runRemoteOperation(root: FileSystemDirectoryHandle, operation: RemoteOperation, getSession: GetRemoteSession, guard: () => void, signal?: AbortSignal): Promise<void>;

package/dist/{repository-BYno-5f8.js → repository-xIv0iZkj.js}

@@ -1,5 +1,5 @@
 import { i as __toESM, n as init_objectSpread2, r as __commonJSMin, t as _objectSpread2 } from "./objectSpread2-Dkd68nJH.js";
-import { a as createTwoFilesPatch, i as isAssetName, n as assetsDirectoryParts, r as folderSettingsLimit, t as assetLimit } from "./project-asset-paths-KV715791.js";
+import { f as createTwoFilesPatch, i as isAssetName, n as assetsDirectoryParts, o as createProjectSourceDiff, r as folderSettingsLimit, t as assetLimit } from "./project-asset-paths-nL5sV35A.js";
 import { a as _OverloadYield, i as _wrapAsyncGenerator, o as _asyncIterator, r as createGitSmartHttp, t as GitSmartHttpError } from "./smart-http-BmHEkE7K.js";
 // node_modules/inherits/inherits_browser.js
 var require_inherits_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -16929,6 +16929,79 @@ async function walk({ fs, dir, gitdir = join(dir, ".git"), trees, map, reduce, i
 		throw err;
 	}
 }
+/**
+* Write a ref which refers to the specified SHA-1 object id, or a symbolic ref which refers to the specified ref.
+*
+* @param {object} args
+* @param {FsClient} args.fs - a file system client
+* @param {string} [args.dir] - The [working tree](dir-vs-gitdir.md) directory path
+* @param {string} [args.gitdir=join(dir,'.git')] - [required] The [git directory](dir-vs-gitdir.md) path
+* @param {string} args.ref - The name of the ref to write
+* @param {string} args.value - When `symbolic` is false, a ref or an SHA-1 object id. When true, a ref starting with `refs/`.
+* @param {boolean} [args.force = false] - Instead of throwing an error if a ref named `ref` already exists, overwrite the existing ref.
+* @param {boolean} [args.symbolic = false] - Whether the ref is symbolic or not.
+*
+* @returns {Promise<void>} Resolves successfully when filesystem operations are complete
+*
+* @example
+* await git.writeRef({
+*   fs,
+*   dir: '/tutorial',
+*   ref: 'refs/heads/another-branch',
+*   value: 'HEAD'
+* })
+* await git.writeRef({
+*   fs,
+*   dir: '/tutorial',
+*   ref: 'HEAD',
+*   value: 'refs/heads/another-branch',
+*   force: true,
+*   symbolic: true
+* })
+* console.log('done')
+*
+*/
+async function writeRef({ fs: _fs, dir, gitdir = join(dir, ".git"), ref, value, force = false, symbolic = false }) {
+	try {
+		assertParameter("fs", _fs);
+		assertParameter("gitdir", gitdir);
+		assertParameter("ref", ref);
+		assertParameter("value", value);
+		const fs = new FileSystem(_fs);
+		if (!isValidRef(ref, true)) throw new InvalidRefNameError(ref, import_lib.default.clean(ref));
+		const updatedGitdir = await discoverGitdir({
+			fsp: fs,
+			dotgit: gitdir
+		});
+		if (!force && await GitRefManager.exists({
+			fs,
+			gitdir: updatedGitdir,
+			ref
+		})) throw new AlreadyExistsError("ref", ref);
+		if (symbolic) await GitRefManager.writeSymbolicRef({
+			fs,
+			gitdir: updatedGitdir,
+			ref,
+			value
+		});
+		else {
+			value = await GitRefManager.resolve({
+				fs,
+				gitdir: updatedGitdir,
+				ref: value
+			});
+			await GitRefManager.writeRef({
+				fs,
+				gitdir: updatedGitdir,
+				ref,
+				value
+			});
+		}
+	} catch (err) {
+		err.caller = "git.writeRef";
+		throw err;
+	}
+}
 // src/filesystem.ts
 var GitPanelError = class extends Error {
 	constructor(code, message = code) {
@@ -17342,8 +17415,104 @@ function _asyncGeneratorDelegate(t) {
 }
 // src/remote-operations.ts
 init_objectSpread2();
-async function runRemoteOperation(root, operation, getSession, guard, signal) {
+var sessionCodes = [
+	"SESSION_REQUIRED",
+	"SESSION_UNAVAILABLE",
+	"SESSION_EXPIRED",
+	"REAUTH_REQUIRED",
+	"INVALID_SESSION"
+];
+async function checkRefspecs(options) {
+	if ((await getConfigAll(_objectSpread2(_objectSpread2({}, options), {}, { path: "remote.origin.fetch" }))).some((spec) => !/^\+?refs\/heads\/[^:\s]+:refs\/remotes\/origin\/[^:\s]+$/u.test(spec))) throw new GitPanelError("unsupported");
+}
+/**
+* Where a fetched pull request head is kept: outside `refs/heads`, `refs/remotes` and `refs/tags`, so Git CLI lists it
+* with `git for-each-ref refs/pull` and `git log --all` but not as a branch or tag, `git fetch --prune` leaves it alone,
+* and `git gc` keeps its objects. Each fetch of the same pull request replaces it.
+*/
+var pullRequestRef = (number) => `refs/pull/origin/${number}/head`;
+/**
+* Fetches GitHub's `refs/pull/<number>/head` together with every branch, over the connection's Git Smart HTTP, like
+* `git fetch origin refs/pull/<number>/head`. The branches update `refs/remotes/origin/*` as fetch does, and the head
+* is kept at `pullRequestRef(number)`. The work tree, the index, HEAD and `.git/config` are never written. The writes
+* are staged first and applied together, under the same lock as fetch, pull and push.
+*/
+async function runPullRequestFetch(root, number, getSession, guard, signal) {
 	var _globalThis$navigator;
+	if (!Number.isSafeInteger(number) || number < 1) throw new GitPanelError("pullRequestNotFound");
+	const execute = async () => {
+		var _result$defaultBranch;
+		guard();
+		const transaction = createMutationFs(root, false);
+		const options = {
+			fs: transaction.fs,
+			dir: "/",
+			gitdir: "/.git",
+			cache: {}
+		};
+		const remote = await getConfig(_objectSpread2(_objectSpread2({}, options), {}, { path: "remote.origin.url" }));
+		if (typeof remote !== "string") throw new GitPanelError("session");
+		await checkRefspecs(options);
+		const session = await getSession(remote, false);
+		if (!session) throw new GitPanelError("session");
+		guard();
+		const transport = createGitSmartHttp({
+			remote,
+			connection: session.connection,
+			getSession: () => getSession(remote, false),
+			signal
+		});
+		const source = `refs/pull/${number}/head`;
+		let result;
+		try {
+			result = await fetch(_objectSpread2(_objectSpread2(_objectSpread2({}, options), transport), {}, {
+				remote: "origin",
+				remoteRef: source,
+				tags: false
+			}));
+		} catch (error) {
+			const { code, data } = error;
+			if (code === "NotFoundError" && (data === null || data === void 0 ? void 0 : data.what) === source) throw new GitPanelError("pullRequestNotFound");
+			throw remoteError(error);
+		}
+		const head = result.fetchHead;
+		if (!head || !/^[0-9a-f]{40}$/u.test(head)) throw new GitPanelError("remoteFailed");
+		const ref = pullRequestRef(number);
+		await writeRef(_objectSpread2(_objectSpread2({}, options), {}, {
+			ref,
+			value: head,
+			force: true
+		}));
+		const branches = (await listBranches(_objectSpread2(_objectSpread2({}, options), {}, { remote: "origin" }))).filter((name) => name !== "HEAD").sort();
+		const advertised = ((_result$defaultBranch = result.defaultBranch) === null || _result$defaultBranch === void 0 ? void 0 : _result$defaultBranch.startsWith("refs/heads/")) ? result.defaultBranch.slice(11) : null;
+		await transaction.commit(guard);
+		return {
+			number,
+			head,
+			ref,
+			defaultBranch: advertised && branches.includes(advertised) ? advertised : null,
+			branches
+		};
+	};
+	return ((_globalThis$navigator = globalThis.navigator) === null || _globalThis$navigator === void 0 ? void 0 : _globalThis$navigator.locks) ? navigator.locks.request("tw-plus-git-mutation", execute) : execute();
+}
+/** Maps a failed read from GitHub to what the person can act on: the connection, access, or the network. */
+function remoteError(error) {
+	if (error instanceof GitPanelError) return error;
+	if (error instanceof GitSmartHttpError) {
+		if (sessionCodes.includes(error.code)) return new GitPanelError("session");
+		if (error.code === "FORBIDDEN") return new GitPanelError("forbidden");
+		if ([
+			"NETWORK_ERROR",
+			"UPSTREAM_FAILURE",
+			"UPSTREAM_TIMEOUT",
+			"RATE_LIMITED"
+		].includes(error.code)) return new GitPanelError("network");
+	}
+	return new GitPanelError("remoteFailed");
+}
+async function runRemoteOperation(root, operation, getSession, guard, signal) {
+	var _globalThis$navigator2;
 	const execute = async () => {
 		guard();
 		const transaction = createMutationFs(root, operation === "pull");
@@ -17361,7 +17530,7 @@ async function runRemoteOperation(root, operation, getSession, guard, signal) {
 		const trackingRemote = await config("branch." + ref + ".remote");
 		const trackingRef = await config("branch." + ref + ".merge");
 		if (trackingRemote && trackingRemote !== "origin" || trackingRef && !trackingRef.startsWith("refs/heads/")) throw new GitPanelError("unsupported");
-		if ((await getConfigAll(_objectSpread2(_objectSpread2({}, options), {}, { path: "remote.origin.fetch" }))).some((spec) => !/^\+?refs\/heads\/[^:\s]+:refs\/remotes\/origin\/[^:\s]+$/u.test(spec))) throw new GitPanelError("unsupported");
+		await checkRefspecs(options);
 		if (operation === "pull") {
 			if ((await statusMatrix(_objectSpread2(_objectSpread2({}, options), {}, { refresh: false }))).some(([, head, worktree, stage]) => head !== worktree || head !== stage)) throw new GitPanelError("pullUnsafe");
 			await walk(_objectSpread2(_objectSpread2({}, options), {}, {
@@ -17435,10 +17604,15 @@ async function runRemoteOperation(root, operation, getSession, guard, signal) {
 			throw error;
 		}
 	};
-	return ((_globalThis$navigator = globalThis.navigator) === null || _globalThis$navigator === void 0 ? void 0 : _globalThis$navigator.locks) ? navigator.locks.request("tw-plus-git-mutation", execute) : execute();
+	return ((_globalThis$navigator2 = globalThis.navigator) === null || _globalThis$navigator2 === void 0 ? void 0 : _globalThis$navigator2.locks) ? navigator.locks.request("tw-plus-git-mutation", execute) : execute();
 }
 // src/local-operations.ts
 init_objectSpread2();
+/**
+* The local branch a pull request is opened on: `pr/<number>`, a name `git check-ref-format --branch` accepts. It is
+* created at the fetched head (`pullRequestRef(number)`) and is an ordinary branch afterwards.
+*/
+var pullRequestBranch = (number) => `pr/${number}`;
 var missing = (error) => {
 	var _errorCode;
 	return [
@@ -17490,6 +17664,7 @@ async function runLocalOperation(root, operation, guard) {
 			}
 			if (operation.kind === "createBranch") {
 				let object;
+				if (operation.reuse && operation.at === void 0) throw new GitPanelError("invalid");
 				if (operation.at !== void 0) {
 					if (operation.fromRemote || !/^[0-9a-f]{40}$/.test(operation.at)) throw new GitPanelError("invalid");
 					object = await readCommit(_objectSpread2(_objectSpread2({}, options), {}, { oid: operation.at })).then(() => operation.at, () => {
@@ -17503,7 +17678,15 @@ async function runLocalOperation(root, operation, guard) {
 				else object = await resolveRef(_objectSpread2(_objectSpread2({}, options), {}, { ref: "HEAD" })).catch(() => {
 					throw new GitPanelError("unsupported");
 				});
-				try {
+				let existing;
+				if (operation.reuse && (await listBranches(options)).includes(name)) {
+					existing = await resolveRef(_objectSpread2(_objectSpread2({}, options), {}, { ref: local }));
+					if (existing !== object) throw new GitPanelError("pullRequestBranch");
+				}
+				if (existing === void 0) {
+					if ((await listBranches(options)).some((branch) => branch !== name && (name.startsWith(`${branch}/`) || branch.startsWith(`${name}/`)))) throw new GitPanelError("branchConflict");
+				}
+				if (existing === void 0) try {
 					await branch(_objectSpread2(_objectSpread2({}, options), {}, {
 						ref: name,
 						object,
@@ -17583,6 +17766,8 @@ init_objectSpread2();
 var historyPageSize = 50;
 var projectSourceLimit = 16777216;
 var emptyTree = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+var isSha = (value) => typeof value === "string" && /^[0-9a-f]{40}$/u.test(value);
+var validBranch = (name) => /^[^\s~^:?*[\\]+$/u.test(name) && !name.startsWith("/") && !name.endsWith("/") && !name.endsWith(".lock") && !name.includes("..") && !name.includes("//") && !name.includes("@{");
 var textLimit = 1048576;
 var inScope = (path, scope) => !scope || path === scope || path.startsWith(scope + "/");
 var probeLimit = 5e3;
@@ -18258,6 +18443,146 @@ async function openRepository(root) {
 			}
 		};
 	};
+	const hasCommit = async (oid) => {
+		try {
+			await readCommit(_objectSpread2(_objectSpread2({}, options), {}, {
+				cache,
+				oid
+			}));
+			return true;
+		} catch (_unused5) {
+			return false;
+		}
+	};
+	/** Lists the paths that differ between two trees, skipping subtrees with the same object. */
+	const treeChanges = async (before, after) => {
+		const file = async (entry) => entry && await entry.type() !== "tree" ? {
+			oid: await entry.oid(),
+			mode: await entry.mode()
+		} : null;
+		return (await walk(_objectSpread2(_objectSpread2({}, options), {}, {
+			cache,
+			trees: [TREE({ ref: before }), TREE({ ref: after })],
+			map: async (path, [a, b]) => {
+				if (path === ".") return;
+				if (a && b && await a.oid() === await b.oid() && await a.mode() === await b.mode()) return null;
+				const change = {
+					path,
+					before: await file(a),
+					after: await file(b)
+				};
+				return change.before || change.after ? change : void 0;
+			}
+		}))).sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+	};
+	const readBlobText = async (entry) => {
+		if (!entry) return "{\"targets\":[]}\n";
+		if (entry.mode !== 33188 && entry.mode !== 33261) throw new GitPanelError("unsupported");
+		const { blob } = await readBlob(_objectSpread2(_objectSpread2({}, options), {}, {
+			cache,
+			oid: entry.oid
+		}));
+		if (blob.byteLength > projectSourceLimit) throw new GitPanelError("large");
+		return new TextDecoder("utf-8", { fatal: true }).decode(blob);
+	};
+	const readTreeAsset = async (ref, folder, md5ext, signal) => {
+		if (signal.aborted) return null;
+		const source = {
+			kind: "tree",
+			ref
+		};
+		const settings = await readVersion(source, [...folder, "sb3-source.json"].join("/"), folderSettingsLimit);
+		const directory = assetsDirectoryParts(settings && new TextDecoder().decode(settings));
+		if (!directory || signal.aborted) return null;
+		const bytes = await readVersion(source, [
+			...folder,
+			...directory,
+			md5ext
+		].join("/"), assetLimit);
+		return bytes && !signal.aborted ? new Blob([bytes]) : null;
+	};
+	const pullRequestAssets = (versions) => ({ version, md5ext, signal }) => {
+		const location = versions[version];
+		if (!location || !isAssetName(md5ext) || signal.aborted) return Promise.resolve(null);
+		return serial(() => readTreeAsset(location.ref, pathParts(location.path).slice(0, -1), md5ext, signal)).catch(() => null);
+	};
+	/** Compares a fetched pull request head with its merge base, from local Git objects only. */
+	const readPullRequest = async (head, base) => {
+		var _added$get, _base$branch;
+		if (!isSha(head) || !await hasCommit(head)) throw new GitPanelError("pullRequestNotFound");
+		let sha;
+		if (isSha(base.sha) && await hasCommit(base.sha)) sha = base.sha;
+		else if (base.branch !== void 0 && validBranch(base.branch)) try {
+			sha = await resolveRef(_objectSpread2(_objectSpread2({}, options), {}, { ref: "refs/remotes/origin/" + base.branch }));
+		} catch (_unused6) {}
+		if (!sha || !await hasCommit(sha)) throw new GitPanelError("baseMissing");
+		const [mergeBase = null] = await findMergeBase(_objectSpread2(_objectSpread2({}, options), {}, {
+			cache,
+			oids: [sha, head]
+		}));
+		const changes = await treeChanges(mergeBase !== null && mergeBase !== void 0 ? mergeBase : emptyTree, head);
+		const added = /* @__PURE__ */ new Map();
+		for (const change of changes) if (!change.before && change.after) added.set(change.after.oid, [...(_added$get = added.get(change.after.oid)) !== null && _added$get !== void 0 ? _added$get : [], change]);
+		const renamed = /* @__PURE__ */ new Map();
+		for (const change of changes) {
+			const candidates = change.before && !change.after ? added.get(change.before.oid) : void 0;
+			const target = candidates === null || candidates === void 0 ? void 0 : candidates.find((candidate) => !renamed.has(candidate));
+			if (target) renamed.set(target, change);
+		}
+		const removedByRename = new Set(renamed.values());
+		const files = [];
+		for (const change of changes) {
+			var _from$before;
+			if (removedByRename.has(change)) continue;
+			const from = renamed.get(change);
+			const before = (_from$before = from === null || from === void 0 ? void 0 : from.before) !== null && _from$before !== void 0 ? _from$before : change.before;
+			const previousPath = from === null || from === void 0 ? void 0 : from.path;
+			const status = !before ? "added" : !change.after ? "removed" : "updated";
+			if (change.path.split("/").pop() !== "project.source.json") {
+				files.push({
+					path: change.path,
+					previousPath,
+					status
+				});
+				continue;
+			}
+			try {
+				const patch = createProjectSourceDiff(await readBlobText(before), await readBlobText(change.after));
+				const loadAsset = pullRequestAssets({
+					before: before && mergeBase ? {
+						ref: mergeBase,
+						path: previousPath !== null && previousPath !== void 0 ? previousPath : change.path
+					} : null,
+					after: change.after ? {
+						ref: head,
+						path: change.path
+					} : null
+				});
+				files.push({
+					path: change.path,
+					previousPath,
+					patch,
+					loadAsset
+				});
+			} catch (_unused7) {
+				files.push({
+					path: change.path,
+					previousPath,
+					status,
+					unavailable: true
+				});
+			}
+		}
+		return {
+			base: {
+				ref: (_base$branch = base.branch) !== null && _base$branch !== void 0 ? _base$branch : null,
+				sha
+			},
+			head,
+			mergeBase,
+			files
+		};
+	};
 	const directoryAt = async (path) => {
 		let directory = root;
 		for (const part of pathParts(path)) directory = await directory.getDirectoryHandle(part);
@@ -18335,6 +18660,20 @@ async function openRepository(root) {
 				throw error;
 			}
 		}),
+		/**
+		* Fetches a pull request's head (`refs/pull/<number>/head`, which also covers pull requests from forks) and every
+		* branch over the connection; see `runPullRequestFetch`. Only Git objects and refs are written.
+		*/
+		fetchPullRequest: (number, getSession, guard, signal) => serial(async () => {
+			const result = await runPullRequestFetch(root, number, getSession, guard, signal);
+			cache = {};
+			return result;
+		}),
+		/**
+		* Reads the changes of a fetched pull request head against a base, from local Git objects: the changed paths
+		* from the merge base to the head, and each project file's diff with assets read from the same commits.
+		*/
+		readPullRequest: (head, base) => serial(() => readPullRequest(head, base)),
 		/** Stages, unstages or commits; see `runLocalOperation`. `guard` throws to stop before each write. */
 		localOperation: (operation, guard) => serial(() => runLocalOperation(root, operation, guard)),
 		/**
@@ -18350,7 +18689,7 @@ async function openRepository(root) {
 					filepath: path
 				}));
 				return tree.length > 0;
-			} catch (_unused5) {
+			} catch (_unused8) {
 				return false;
 			}
 		}),
@@ -18378,4 +18717,4 @@ async function openRepository(root) {
 		projectAssetLoader: (snapshot, folder, comparison) => ({ version, md5ext, signal }) => !isAssetName(md5ext) || signal.aborted ? Promise.resolve(null) : serial(() => readFolderAsset(snapshot, pathParts(folder), () => comparisonSource(snapshot, comparison, version), md5ext, signal)).catch(() => null)
 	};
 }
-export { createReadOnlyFs as a, GitPanelError as i, openRepository as n, upstreamWalkLimit as r, historyPageSize as t };
+export { pullRequestRef as a, pullRequestBranch as i, openRepository as n, GitPanelError as o, upstreamWalkLimit as r, createReadOnlyFs as s, historyPageSize as t };

package/dist/repository.d.ts

@@ -1,7 +1,10 @@
+import type { ProjectSourceReviewFile } from './project-source-review.js';
 import type { LocalOperation } from './local-operations.js';
 import type { GetRemoteSession, RemoteOperation } from './remote-operations.js';
 import type { ProjectAssetLoader } from './project-assets.js';
 export { createReadOnlyFs, GitPanelError } from './filesystem.js';
+export { pullRequestRef } from './remote-operations.js';
+export type { PullRequestFetch } from './remote-operations.js';
 export type ChangeGroup = 'staged' | 'unstaged' | 'untracked' | 'commit';
 export interface FileChange {
     path: string;
@@ -14,6 +17,25 @@ export interface FileChange {
     /** For `commit` changes, the commit compared with its first parent. */
     commit?: string;
 }
+/** A version of the pull request's base to compare with: GitHub's base commit when known, else a branch on origin. */
+export interface PullRequestBase {
+    /** The base commit GitHub reported, used when the fetch brought it. */
+    sha?: string;
+    /** The base branch, read from `refs/remotes/origin/<branch>` when `sha` is missing or not local. */
+    branch?: string;
+}
+export interface PullRequestFiles {
+    /** The base that was compared: the branch it was named by, if any, and its commit. */
+    base: {
+        ref: string | null;
+        sha: string;
+    };
+    head: string;
+    /** The merge base of `base.sha` and `head`, like GitHub's three-dot comparison; `null` for unrelated histories. */
+    mergeBase: string | null;
+    /** Every changed path from the merge base to the head, with project data as a project-source diff. */
+    files: ProjectSourceReviewFile[];
+}
 export interface Commit {
     oid: string;
     message: string;
@@ -116,6 +138,16 @@ export declare function openRepository(root: FileSystemDirectoryHandle): Promise
     probe: (scope?: string) => Promise<string>;
     readOrigin: () => Promise<any>;
     remoteOperation: (operation: RemoteOperation, getSession: GetRemoteSession, guard: () => void, signal?: AbortSignal) => Promise<void>;
+    /**
+     * Fetches a pull request's head (`refs/pull/<number>/head`, which also covers pull requests from forks) and every
+     * branch over the connection; see `runPullRequestFetch`. Only Git objects and refs are written.
+     */
+    fetchPullRequest: (number: number, getSession: GetRemoteSession, guard: () => void, signal?: AbortSignal) => Promise<import("./remote-operations.js").PullRequestFetch>;
+    /**
+     * Reads the changes of a fetched pull request head against a base, from local Git objects: the changed paths
+     * from the merge base to the head, and each project file's diff with assets read from the same commits.
+     */
+    readPullRequest: (head: string, base: PullRequestBase) => Promise<PullRequestFiles>;
     /** Stages, unstages or commits; see `runLocalOperation`. `guard` throws to stop before each write. */
     localOperation: (operation: LocalOperation, guard: () => void) => Promise<void>;
     /**

package/dist/repository.js

@@ -1 +1 @@
-export { i as GitPanelError, a as createReadOnlyFs, t as historyPageSize, n as openRepository, r as upstreamWalkLimit } from "./repository-BYno-5f8.js";
+export { o as GitPanelError, s as createReadOnlyFs, t as historyPageSize, n as openRepository, a as pullRequestRef, r as upstreamWalkLimit } from "./repository-xIv0iZkj.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubohiroya/turbowarp-plus-editor-git",
-  "version": "0.16.1",
+  "version": "0.17.0",
   "description": "Read-only local Git panel for TurboWarp Plus Editor",
   "type": "module",
   "license": "MPL-2.0",

package/src/filesystem.ts

@@ -2,7 +2,8 @@ export class GitPanelError extends Error {
     constructor(public code: 'invalid' | 'changed' | 'large' | 'unsupported' | 'pullUnsafe' | 'diverged' |
         'session' | 'pushUnknown' | 'pushRefresh' | 'rollbackFailed' | 'remoteFailed' |
         'saveFirst' | 'author' | 'nothingStaged' | 'commitMessage' |
-        'switchUnsafe' | 'branchExists' | 'branchName' | 'locked', message: string = code) {
+        'switchUnsafe' | 'branchExists' | 'branchConflict' | 'pullRequestBranch' | 'branchName' | 'locked' |
+        'pullRequestNotFound' | 'forbidden' | 'network' | 'baseMissing', message: string = code) {
         super(message);
         this.name = 'GitPanelError';
     }

package/src/github-pull-requests.ts

@@ -165,6 +165,13 @@ export function createGitHubPullRequests(repository: string, send: typeof fetch
         await request(repoPath(name) + '/contents/' + contentPath(path) + '?ref=' + revision, signal, 'application/vnd.github.raw+json'), sourceLimit);
 
     return {
+        /** Reads one pull request's title, description, state and both revisions, without its files (one request). */
+        async metadata(number: number, signal: AbortSignal) {
+            if (!Number.isSafeInteger(number) || number < 1) throw invalidResponse();
+            const pr = await metadata(number, signal);
+            if (pr.number !== number) throw invalidResponse();
+            return {...pr, url: 'https://github.com/' + repository + '/pull/' + number};
+        },
         async list(page: number, signal: AbortSignal) {
             const result = await json(repo + '/pulls?state=all&sort=updated&per_page=20&page=' + page, signal);
             if (!Array.isArray(result)) throw invalidResponse();