@gitkraken/core-gitlens 0.5.109 → 0.5.111

package/src/git/models/pullRequest.ts

@@ -11,7 +11,6 @@ export type { PullRequestState };
 
 export interface PullRequestShape extends IssueOrPullRequest {
 	readonly author: PullRequestMember;
-	readonly body?: string;
 	/**
 	 * Canonical base-repository identity returned by the provider. Some providers
 	 * scope pull-request ids to a repository, so consumers must not have to infer
@@ -23,11 +22,23 @@ export interface PullRequestShape extends IssueOrPullRequest {
 	readonly isDraft?: boolean;
 	readonly additions?: number;
 	readonly deletions?: number;
+	readonly filesChanged?: number;
+	readonly body?: string;
 	readonly mergeableState?: PullRequestMergeableState;
 	readonly reviewDecision?: PullRequestReviewDecision;
 	readonly reviewRequests?: PullRequestReviewer[];
+	/**
+	 * Reviews already submitted, as opposed to the still-pending {@link reviewRequests}. Absent means the read
+	 * didn't fetch reviews; empty means nobody has reviewed. Those are different answers and neither substitutes
+	 * for the other, so which one you get is provider- and read-dependent: GitHub/GHE carry reviews on the
+	 * repo-scoped read and the filtered search, and on the account-wide read only where `includeReviews` opts
+	 * into the full projection, while GitLab never populates the field at all.
+	 * {@link PullRequestReviewer.commitOid} is the narrower promise: only the full GitHub/GHE projection has it.
+	 */
+	readonly latestReviews?: PullRequestReviewer[];
 	readonly assignees?: PullRequestMember[];
 	readonly project?: IssueProject;
+	readonly stack?: PullRequestStackInfo;
 	readonly number?: number;
 	readonly authoredByMe?: boolean;
 }
@@ -65,6 +76,12 @@ export class PullRequest implements PullRequestShape {
 		public readonly statusCheckRollupState?: PullRequestStatusCheckRollupState,
 		public readonly project?: IssueProject,
 		public readonly version?: number,
+		/** Commits on the head that aren't on the base. Appended rather than slotted with the other counts:
+		 *  this constructor is positional and every mapper passes through it. */
+		public readonly commitCount?: number,
+		public readonly stack?: PullRequestStackInfo,
+		public readonly filesChanged?: number,
+		/** The pull request's description, as markdown. */
 		public readonly body?: string,
 		public readonly number?: number,
 		public readonly authoredByMe?: boolean,
@@ -145,6 +162,10 @@ export interface PullRequestMember {
 	 * presentation.
 	 */
 	name?: string;
+	/** The provider's handle for this person, when it has one — GitHub's login, Azure's `uniqueName` (a UPN,
+	 *  so an email), Bitbucket's mutable `nickname`. Display/labelling only: it is neither guaranteed present
+	 *  (GitLab's native mapper has none) nor a stable identity, so never key a match off it. */
+	username?: string;
 	avatarUrl?: string;
 	url?: string;
 }
@@ -154,12 +175,50 @@ export enum PullRequestFilter {
 	Author = 'author',
 	Assignee = 'assignee',
 	ReviewRequested = 'review-requested',
+	/**
+	 * PRs the user has already reviewed (GitHub `reviewed-by:@me`), as opposed to `ReviewRequested` (a
+	 * still-pending request). Distinguishes "waiting on the author after my review" from "waiting for my
+	 * review". Not expressible on the repo-scoped listing — no provider SDK exposes a reviewed-by axis there —
+	 * so it is advertised for the account-wide read and for the filtered search (which can still bound itself
+	 * to repositories or an org), never under `supportedPullRequestFilters`.
+	 */
+	Reviewed = 'reviewed-by',
 	Mention = 'mention',
 }
 
 /** Selects which pull request states a read should include. `all` covers open + closed + merged. */
 export type PullRequestStateFilter = 'open' | 'closed' | 'merged' | 'all';
 
+/**
+ * A field a pull-request read can be ordered by, provider-neutral.
+ *
+ * Only two, and deliberately so — unlike {@link IssueSortField} this is the INTERSECTION of what GitHub's PR
+ * search can order by server-side and what a {@link PullRequestShape} carries, because the filtered PR search
+ * always merges its relationship × state facets in the facade and so must re-order the union itself (see
+ * `getPullRequestComparator`). `created` and `updated` are both. A field GitHub cannot order PRs by, or one a
+ * merged page can't reproduce, is left out rather than advertised and then approximated: relevance is unstable
+ * and has no comparable value on a merge, and priority is not a pull-request concept on any provider that has PRs.
+ */
+export type PullRequestSortField =
+	/** Creation date. */
+	| 'created'
+	/** Last activity. */
+	| 'updated';
+
+/**
+ * How a pull-request read is ordered, as `field:direction` — the same serializable shape {@link IssueSorting}
+ * and `BranchSorting` use, so a consumer can persist it, compare it, or bind it straight to a setting or dropdown.
+ */
+export type PullRequestSorting = `${PullRequestSortField}:asc` | `${PullRequestSortField}:desc`;
+
+/**
+ * The order the filtered pull-request search applies when the caller asks for none: most recently updated first,
+ * which is what it served before ordering was an option. Named once rather than per layer — the criteria model
+ * documents it, the GitHub query emits it, and the result-ceiling warning quotes it — so the three cannot
+ * disagree about what "the default" is.
+ */
+export const defaultPullRequestSort: PullRequestSorting = 'updated:desc';
+
 /**
  * What the filtered pull-request search narrows on.
  *
@@ -181,8 +240,27 @@ export interface PullRequestSearchCriteria {
 	relationships?: PullRequestFilter[];
 	/** Pull request states to union. Empty/omitted reads open PRs; `all` subsumes every other member. */
 	states?: PullRequestStateFilter[];
+	/** ISO date (`YYYY-MM-DD`). The most effective narrowing criterion by far on a large scope. */
+	updatedAfter?: string;
+	/** ISO date (`YYYY-MM-DD`). */
+	createdAfter?: string;
 	/** Includes PRs from archived repositories. They are excluded by default. */
 	includeArchived?: boolean;
+	/**
+	 * Narrows on draft state: `true` returns only drafts, `false` only ready-for-review PRs. Omitted places no
+	 * constraint. A boolean rather than a truthy flag because `false` is a distinct request, not the absence of one.
+	 */
+	draft?: boolean;
+	/**
+	 * How to order the results. Omitted means `updated:desc`, which is what this search has always served.
+	 *
+	 * Validated all-or-nothing against {@link PullRequestSearchCapabilities.sorts} like every other criterion: a
+	 * key the provider can't express server-side refuses the WHOLE read rather than falling back to the default,
+	 * because combined with the provider's result ceiling another order returns a different subset than was asked
+	 * for and the paging that comes with it describes that other subset. Do not change it mid-pagination — a
+	 * cursor carries the sort it was produced under; drop the cursor instead of threading it under a new key.
+	 */
+	sort?: PullRequestSorting;
 }
 
 /**
@@ -195,11 +273,21 @@ export interface PullRequestSearchCapabilities {
 	/** Individual state values the provider can union in one logical search. */
 	states: PullRequestStateFilter[];
 	text: boolean;
+	updatedAfter: boolean;
+	createdAfter: boolean;
 	includeArchived: boolean;
+	/** Whether the provider can constrain the search by draft state server-side. */
+	draft: boolean;
 	/** Whether the manager's repository-descriptor scope is supported. */
 	repositoryScope: boolean;
 	/** Whether the manager's organization scope is supported. */
 	organizationScope: boolean;
+	/**
+	 * Sort keys the search can express server-side. Always contains at least `updated:desc` — the historical
+	 * default — when the search exists at all, so it is never empty for a usable surface; a provider without a
+	 * filtered PR search reports an empty `relationships`, which is already the signal there is no surface to order.
+	 */
+	sorts: PullRequestSorting[];
 }
 
 export interface PullRequestRef {
@@ -223,10 +311,38 @@ export interface PullRequestRefs {
 	isCrossRepository: boolean;
 }
 
+/**
+ * A pull request's membership in a stack — an ordered chain of dependent pull requests where each
+ * targets the branch of the one below it.
+ *
+ * `baseRef` is the stack's ultimate target (its trunk) and is NOT the same as `refs.base`, which for
+ * anything above the bottom layer names the layer below. Use `refs.base` to diff a single layer; use
+ * `baseRef` to answer where the work ultimately lands.
+ */
+export interface PullRequestStackInfo {
+	id: string;
+	/** Identifies the stack within its repository. */
+	number: number;
+	/** Total pull requests in the stack. */
+	size: number;
+	/** This pull request's layer, 1-based, where 1 is closest to `baseRef`. */
+	position: number;
+	/** The branch the bottom of the stack targets. */
+	baseRef: string;
+}
+
 export interface PullRequestReviewer {
 	isCodeOwner?: boolean;
 	reviewer: PullRequestMember;
 	state: PullRequestReviewState;
+	/**
+	 * The head commit oid this review was submitted against (GitHub). Lets a consumer tell "the PR moved past
+	 * my review" (oid !== the PR's current head) from a review still at the tip — without a per-review
+	 * timestamp. Only populated where the full GitHub/GHE projection is selected: the filtered search read, and
+	 * an account-wide sweep that opts in with `includeReviews`. Undefined elsewhere, including reviews the
+	 * repo-scoped read carries natively.
+	 */
+	commitOid?: string;
 }
 
 export type PullRequestRepositoryIdentityDescriptor = RequireSomeWithProps<

package/src/git/models/repository.ts

@@ -7,12 +7,12 @@ import type { UnifiedDisposable } from '../../utils/disposable.js';
 import { createDisposable } from '../../utils/disposable.js';
 import type { Event } from '../../utils/event.js';
 import { Emitter } from '../../utils/event.js';
-import { basename, normalizePath } from '../../utils/path.js';
+import { some } from '../../utils/iterable.js';
+import { basename, isDescendant, normalizePath } from '../../utils/path.js';
 import type { Uri } from '../../utils/uri.js';
-import { fileUri } from '../../utils/uri.js';
 import type { GitProviderDescriptor } from '../providers/types.js';
 import { getCommonRepositoryUri } from '../utils/repository.utils.js';
-import type { WatcherRepoChangeEvent } from '../watching/changeEvent.js';
+import type { WatcherRepoChangeEvent, WorkingTreeChangeEvent } from '../watching/changeEvent.js';
 import type { RepositoryWatchService, WatchHandle, WatchHooks } from '../watching/watchService.js';
 import type { RepositorySubscription } from '../watching/watchSession.js';
 import { RepositoryChangeEvent } from './repositoryChangeEvent.js';
@@ -107,10 +107,44 @@ export interface RepositoryInit {
 	readonly watchService: RepositoryWatchService;
 }
 
-export interface RepositoryWorkingTreeChangeEvent {
-	readonly repository: Repository;
-	/** URIs of changed files */
-	readonly uris: ReadonlySet<Uri>;
+/**
+ * An event describing working tree file changes.
+ *
+ * Deliberately exposes no path collection. Consumers react by refreshing, and a refresh re-reads current
+ * state — so the paths only ever gate whether to bother, never what the answer is. A partial set would
+ * read as usable while quietly licensing the one harmful outcome (concluding a file did NOT change), so
+ * {@link changed} is the only way to ask.
+ */
+export class RepositoryWorkingTreeChangeEvent {
+	constructor(
+		readonly repository: Repository,
+		/** Absolute paths changed in this batch; partial when {@link incomplete}. */
+		private readonly paths: ReadonlySet<string>,
+		/** Whether paths were dropped, so {@link paths} can't be used to rule anything out. */
+		private readonly incomplete: boolean,
+	) {}
+
+	/**
+	 * Whether `uri` — or anything beneath it, when it's a folder — changed in this batch.
+	 *
+	 * Conservative: `true` whenever the batch is incomplete, since a miss would then prove nothing. Matches
+	 * on paths rather than URIs so nothing has to be allocated to answer.
+	 */
+	changed(uri: Uri): boolean {
+		if (this.incomplete) return true;
+
+		const path = uri.fsPath;
+		return some(this.paths, p => p === path || isDescendant(p, path));
+	}
+
+	toString(): string {
+		if (this.incomplete) return `{ repository: ${this.repository.name ?? ''}, paths: incomplete }`;
+
+		const [first] = this.paths;
+		return `{ repository: ${this.repository.name ?? ''}, paths(${this.paths.size}): [${first ?? ''}${
+			this.paths.size > 1 ? ', ...' : ''
+		}] }`;
+	}
 }
 
 export class Repository {
@@ -140,7 +174,8 @@ export class Repository {
 	protected _watchHandle: WatchHandle | undefined;
 	protected readonly _watchService: RepositoryWatchService;
 
-	private _pendingWorkingTreeChange?: RepositoryWorkingTreeChangeEvent;
+	private _pendingWorkingTreePaths?: Set<string>;
+	private _pendingWorkingTreeIncomplete = false;
 	private _pendingWorkingTreeFlush = false;
 	private _repoChangeListener: UnifiedDisposable | undefined;
 	/** Outstanding leases on the shared {@link _watchHandle} across `watch()` + `watchWorkingTree()`. */
@@ -318,7 +353,7 @@ export class Repository {
 		if (acquired == null) return createDisposable(() => {});
 
 		const sub = acquired.handle.session.subscribeToWorkingTree({ delayMs: delay });
-		const listener = sub.onDidChangeWorkingTree(e => this.onWorkingTreeChanged(e.paths));
+		const listener = sub.onDidChangeWorkingTree(e => this.onWorkingTreeChanged(e));
 
 		return createDisposable(
 			() => {
@@ -409,24 +444,30 @@ export class Repository {
 	 * `_onDidChangeWorkingTree` emission. Without this coalescing, every WIP-dependent listener
 	 * (graph, file history, compare branch, etc.) would fire N times for N active subscriptions.
 	 */
-	protected onWorkingTreeChanged(paths: ReadonlySet<string>): void {
+	/** Takes the session event whole rather than spreading it across parameters — a subclass override that
+	 *  dropped a trailing positional argument silently defeated this pipeline once already. */
+	protected onWorkingTreeChanged(e: WorkingTreeChangeEvent): void {
 		this._updatedAt = Date.now();
 
-		this._pendingWorkingTreeChange ??= { repository: this, uris: new Set<Uri>() };
-		for (const p of paths) {
-			(this._pendingWorkingTreeChange.uris as Set<Uri>).add(fileUri(p));
+		this._pendingWorkingTreePaths ??= new Set<string>();
+		for (const p of e.paths) {
+			this._pendingWorkingTreePaths.add(p);
 		}
+		this._pendingWorkingTreeIncomplete ||= e.incomplete;
 
 		if (this._pendingWorkingTreeFlush) return;
 
 		this._pendingWorkingTreeFlush = true;
 		queueMicrotask(() => {
 			this._pendingWorkingTreeFlush = false;
-			const e = this._pendingWorkingTreeChange;
-			if (e == null) return;
+			const paths = this._pendingWorkingTreePaths;
+			if (paths == null) return;
+
+			const incomplete = this._pendingWorkingTreeIncomplete;
+			this._pendingWorkingTreePaths = undefined;
+			this._pendingWorkingTreeIncomplete = false;
 
-			this._pendingWorkingTreeChange = undefined;
-			this._onDidChangeWorkingTree.fire(e);
+			this._onDidChangeWorkingTree.fire(new RepositoryWorkingTreeChangeEvent(this, paths, incomplete));
 		});
 	}
 

package/src/git/models/statusFile.ts

@@ -86,6 +86,9 @@ export class GitStatusFile implements GitFile {
 				case 'M':
 					this.workingTreeStatus = GitFileWorkingTreeStatus.Modified;
 					break;
+				case 'T':
+					this.workingTreeStatus = GitFileWorkingTreeStatus.TypeChanged;
+					break;
 			}
 		}
 	}

package/src/git/providers/branches.ts

@@ -102,6 +102,12 @@ export interface GitBranchesSubProvider {
 		targetBranch: string,
 		cancellation?: AbortSignal,
 	): Promise<ConflictDetectionResult>;
+	/** Detects conflicts when an autostash is reapplied onto the tree an integration produced */
+	getPotentialStashReapplyConflicts?(
+		repoPath: string,
+		ontoTreeOid: string,
+		cancellation?: AbortSignal,
+	): Promise<ConflictDetectionResult>;
 	getBaseBranchName?(
 		repoPath: string,
 		ref: string,

package/src/git/providers/commits.ts

@@ -8,6 +8,7 @@ import type { GitRevisionRange } from '../models/revision.js';
 import type { SearchQuery } from '../models/search.js';
 import type { CommitSignature, SshSignedCommit } from '../models/signature.js';
 import type { GitUser } from '../models/user.js';
+import type { GitCommandPriority } from '../run.types.js';
 import type { DiffRange } from './types.js';
 
 export interface LeftRightCommitCountResult {
@@ -82,6 +83,16 @@ export interface GitCommitsSubProvider {
 	 *  Cheap early-exit probe (`rev-list --not --remotes <rev> -n 1`) — it does NOT count them. Returns
 	 *  `undefined` when it can't be determined. */
 	hasUnpublishedCommits?(repoPath: string, rev: string, cancellation?: AbortSignal): Promise<boolean | undefined>;
+	/** Batched form of {@link hasUnpublishedCommits}: returns the subset of `shas` with commits not reachable
+	 *  from any remote-tracking ref, in ONE walk rather than a spawn per sha. Pass tips from any worktrees of
+	 *  the same repo — the object store and `refs/remotes` are shared, so a single `repoPath` covers them all.
+	 *  Callers should skip this when the repo has no remotes (every local commit would qualify). */
+	filterUnpublishedShas?(
+		repoPath: string,
+		shas: readonly string[],
+		options?: { priority?: GitCommandPriority },
+		cancellation?: AbortSignal,
+	): Promise<Set<string>>;
 	/** Cheap author/committer date lookup for a single revision. Skips the full commit parse (no files, parents, or message) — use when only the dates are needed. Pass a full SHA so caching stays correct (commits are immutable; refs are not). */
 	getCommitDates?(
 		repoPath: string,

package/src/git/providers/config.ts

@@ -13,8 +13,16 @@ export type GitCoreConfigKeys =
 	| 'gpg.ssh.program'
 	| 'gpg.ssh.allowedSignersFile'
 	| 'init.defaultBranch'
+	/** `merge.autoStash` — whether `git merge` (and so a merging `git pull`) stashes and reapplies uncommitted changes */
+	| 'merge.autoStash'
+	/** `pull.autoStash` — overrides `merge.autoStash`/`rebase.autoStash` for `git pull`, in either mode */
+	| 'pull.autoStash'
 	/** `pull.rebase` — whether `git pull` rebases instead of merging; also accepts `merges`/`interactive` */
 	| 'pull.rebase'
+	/** `rebase.autoStash` — whether `git rebase` (and so a rebasing `git pull`) stashes and reapplies uncommitted changes */
+	| 'rebase.autoStash'
+	/** `rebase.updateRefs` — whether `git rebase` also updates branches pointing to the rebased commits */
+	| 'rebase.updateRefs'
 	| 'user.email'
 	| 'user.name'
 	| 'user.signingkey';
@@ -100,6 +108,16 @@ export interface GitConfigSubProvider {
 		value: string | undefined,
 		options?: { skipInvalidation?: readonly GkConfigInvalidationTarget[] },
 	): Promise<void>;
+	/**
+	 * Drops every gk key stored for `ref` — call when a branch stops existing under that name. Deliberately
+	 * includes user-owned values (`gk-merge-target-user`, `gk-disposition`, `gk-associated-issues`): the
+	 * branch is confirmed gone, and leaving them would hand the next branch reusing that name a dead one's
+	 * starred state and issue links. Only call where git guarantees the name is free —
+	 * a completed delete.
+	 */
+	removeGkConfigBranchSection?(repoPath: string, ref: string): Promise<void>;
+	/** Moves every gk key stored for `oldRef` to `newRef` — call when a branch is renamed. */
+	renameGkConfigBranchSection?(repoPath: string, oldRef: string, newRef: string): Promise<void>;
 
 	getSigningConfig?(repoPath: string): Promise<SigningConfig>;
 	getSigningConfigFlags?(config: SigningConfig): string[];

package/src/git/providers/operations.ts

@@ -112,6 +112,7 @@ export interface GitOperationsSubProvider {
 			 */
 			messageEditor?: string;
 			onto?: string;
+			/** `true` → `--update-refs`, `false` → `--no-update-refs`, omitted → git config (`rebase.updateRefs`) decides. */
 			updateRefs?: boolean;
 			source?: unknown;
 		},

package/src/git/providers/pausedOperations.ts

@@ -10,6 +10,8 @@ export interface GitPausedOperationsSubProvider {
 	continuePausedOperation(
 		repoPath: string,
 		options?: {
+			/** Records the empty commit the operation refused to create, then concludes it (cherry-pick/revert) */
+			allowEmpty?: boolean;
 			skip?: boolean;
 			/** Editor command used if the operation needs to edit a commit message (e.g. `true` to keep the original message without opening an editor) */
 			messageEditor?: string;

package/src/git/providers/status.ts

@@ -37,6 +37,7 @@ export interface GitStatusSubProvider {
 			unstaged?: boolean;
 			untracked?: boolean;
 			throwOnError?: boolean;
+			priority?: GitCommandPriority;
 		},
 		cancellation?: AbortSignal,
 	): Promise<boolean>;

package/src/git/utils/config.utils.ts

@@ -0,0 +1,8 @@
+const falseValues = new Set(['', 'false', 'no', 'off', '0']);
+
+/** Interprets a git config value with git's boolean semantics; `undefined` in → `undefined` out (unset). */
+export function parseGitBoolean(value: string | null | undefined): boolean | undefined {
+	if (value == null) return undefined;
+
+	return !falseValues.has(value.trim().toLowerCase());
+}

package/src/git/utils/issue.utils.ts

@@ -134,6 +134,7 @@ export function serializeIssue(value: IssueShape): IssueShape {
 				: {
 						id: value.author.id,
 						name: value.author.name,
+						username: value.author.username,
 						avatarUrl: value.author.avatarUrl,
 						url: value.author.url,
 					},
@@ -157,6 +158,7 @@ export function serializeIssue(value: IssueShape): IssueShape {
 		assignees: value.assignees.map(assignee => ({
 			id: assignee.id,
 			name: assignee.name,
+			username: assignee.username,
 			avatarUrl: assignee.avatarUrl,
 			url: assignee.url,
 		})),

package/src/git/utils/pausedOperationStatus.utils.ts

@@ -23,30 +23,58 @@ export function getConflictCurrentRef(status: GitPausedOperationStatus): GitRefe
 	return status.current;
 }
 
+/** `name` is the Title Case form for buttons/actions; `prose` is the sentence form ("Cherry-pick paused"). */
 export const pausedOperationStatusStringsByType = {
 	'cherry-pick': {
+		name: 'Cherry Pick',
+		prose: 'Cherry-pick',
 		label: 'Cherry picking',
 		conflicts: 'Resolve conflicts to continue cherry picking',
 		directionality: 'into',
 	},
 	merge: {
+		name: 'Merge',
+		prose: 'Merge',
 		label: 'Merging',
 		conflicts: 'Resolve conflicts to continue merging',
 		directionality: 'into',
 	},
 	rebase: {
+		name: 'Rebase',
+		prose: 'Rebase',
 		label: 'Rebasing',
 		conflicts: 'Resolve conflicts to continue rebasing',
 		directionality: 'onto',
 		pending: 'Pending rebase of',
 	},
 	revert: {
+		name: 'Revert',
+		prose: 'Revert',
 		label: 'Reverting',
 		conflicts: 'Resolve conflicts to continue reverting',
 		directionality: 'in',
 	},
 } as const;
 
+export type PausedOperationVariant = 'conflicts' | 'pending' | 'ready';
+
+/** Codicon per variant — shared so the bar and the WIP badge can't drift. */
+export const pausedOperationVariantIcons: Record<PausedOperationVariant, string> = {
+	conflicts: 'warning',
+	pending: 'circle-outline',
+	ready: 'check',
+};
+
+/** Unresolved conflicts outrank a rebase that hasn't reached its first step — neither can continue, but only conflicts are actionable. */
+export function getPausedOperationVariant(
+	status: GitPausedOperationStatus,
+	hasConflicts: boolean,
+): PausedOperationVariant {
+	if (hasConflicts) return 'conflicts';
+	if (status.type === 'rebase' && status.steps.total === 0) return 'pending';
+	return 'ready';
+}
+
 /**
  * Resolves the correct file paths for each side of a merge conflict diff when the file may have been renamed.
  *

package/src/git/utils/pullRequest.utils.ts

@@ -4,9 +4,72 @@ import type {
 	PullRequestRefs,
 	PullRequestRepositoryIdentityDescriptor,
 	PullRequestShape,
+	PullRequestSortField,
+	PullRequestSorting,
+	PullRequestStackInfo,
 } from '../models/pullRequest.js';
 import { shortenRevision } from './revision.utils.js';
 
+/** How many pull requests a merge action affects — unstacked is always 1; a stacked merge lands either
+ *  just this layer and everything below it (`position`), or the whole stack (`wholeStack`). The one
+ *  source every merge-confirmation and merge-action label counts from, so they can't drift apart.
+ *  Takes only the two fields it needs (not the full {@link PullRequestStackInfo}) since callers on the
+ *  webview side carry narrower serialized stack shapes. */
+export function getStackedMergeCount(
+	stack: Pick<PullRequestStackInfo, 'position' | 'size'> | undefined,
+	options?: { wholeStack?: boolean },
+): number {
+	if (stack == null) return 1;
+	return options?.wholeStack ? stack.size : stack.position;
+}
+
+/**
+ * How each sort field is read off a {@link PullRequestShape}, for the filtered PR search, which MERGES its
+ * relationship × state facets in the facade and so has to order the union itself instead of trusting the
+ * per-facet server order. Only the fields the shape carries appear — the same rule as `getIssueComparator`, and
+ * the reason {@link PullRequestSortField} is just these two.
+ */
+const pullRequestSortValues: Partial<
+	Record<PullRequestSortField, (pr: PullRequestShape) => number | Date | string | undefined>
+> = {
+	created: pr => pr.createdDate,
+	updated: pr => pr.updatedDate,
+};
+
+/**
+ * A comparator for one sort key over normalized pull requests, or `undefined` when the field isn't derivable
+ * from a {@link PullRequestShape} — the signal that the key is only honorable on a SINGLE-origin read where the
+ * provider already ordered the page. Missing values sort LAST in both directions (partitioned before any
+ * arithmetic so two missing values compare equal, exactly as `getIssueComparator` does).
+ *
+ * Note it orders whatever it is handed. Sorting a page already capped at the result ceiling does not make it the
+ * top N.
+ */
+export function getPullRequestComparator(
+	sort: PullRequestSorting,
+): ((a: PullRequestShape, b: PullRequestShape) => number) | undefined {
+	const [field, direction] = sort.split(':') as [PullRequestSortField, 'asc' | 'desc'];
+	const getValue = pullRequestSortValues[field];
+	if (getValue == null) return undefined;
+
+	return (a, b) => {
+		const left = toComparable(getValue(a));
+		const right = toComparable(getValue(b));
+		if (left == null || right == null) {
+			if (left == null && right == null) return 0;
+
+			return left == null ? 1 : -1;
+		}
+
+		const ordered = left < right ? -1 : left > right ? 1 : 0;
+		return direction === 'asc' ? ordered : -ordered;
+	};
+}
+
+function toComparable(value: number | Date | string | undefined): number | string | undefined {
+	return value instanceof Date ? value.getTime() : value;
+}
+
 export interface PullRequestUrlIdentity<TProvider extends string = string> {
 	provider?: TProvider;
 
@@ -41,6 +104,18 @@ export function getPullRequestIdentityFromMaybeUrl(search: string): PullRequestU
 	return prNumber == null ? undefined : { ownerAndRepo: undefined, prNumber: prNumber, provider: undefined };
 }
 
+/** A pull request's display number from its url, or `undefined` for a url naming no pull request. Anchors
+ *  on the provider's pull request path segment (GitHub `pull`, Bitbucket `pull-requests`, GitLab
+ *  `merge_requests`, Azure `pullrequest`) so a digit-leading owner (`github.com/1Password/x/pull/123`)
+ *  can't win. */
+export function getPullRequestNumberFromUrl(url: string): string | undefined {
+	// No loose fallback: `getPullRequestIdentityFromMaybeUrl` scans for any `/<digits>`, which reads a bare
+	// repository url like `github.com/1Password/sdk` as pull request #1. Callers that hold a real pull
+	// request fall back to its id instead, and the one that asks whether a pasted url names a pull request
+	// needs "no" for an answer.
+	return url.match(/(?:pull|pull-requests|merge_requests|pullrequest)\/(\d+)(?:\b|\/|$)/)?.[1];
+}
+
 export function getRepositoryIdentityForPullRequest(
 	pr: PullRequest,
 	headRepo: boolean = true,
@@ -103,6 +178,7 @@ export function serializePullRequest(value: PullRequest): PullRequestShape {
 		author: {
 			id: value.author.id,
 			name: value.author.name,
+			username: value.author.username,
 			avatarUrl: value.author.avatarUrl,
 			url: value.author.url,
 		},
@@ -143,6 +219,7 @@ export function serializePullRequest(value: PullRequest): PullRequestShape {
 		thumbsUpCount: value.thumbsUpCount,
 		reviewDecision: value.reviewDecision,
 		reviewRequests: value.reviewRequests,
+		latestReviews: value.latestReviews,
 		assignees: value.assignees,
 		authoredByMe: value.authoredByMe,
 		project: value.project
@@ -153,6 +230,15 @@ export function serializePullRequest(value: PullRequest): PullRequestShape {
 					resourceName: value.project.resourceName,
 				}
 			: undefined,
+		stack: value.stack
+			? {
+					id: value.stack.id,
+					number: value.stack.number,
+					size: value.stack.size,
+					position: value.stack.position,
+					baseRef: value.stack.baseRef,
+				}
+			: undefined,
 	};
 	return serialized;
 }

package/src/git/watching/changeEvent.ts

@@ -85,6 +85,11 @@ export class WatcherRepoChangeEvent {
  */
 export interface WorkingTreeChangeEvent {
 	readonly repoPath: string;
-	/** Absolute paths of changed files (post-gitignore filtering) */
+	/** Absolute paths of changed files (post-gitignore filtering). Partial when {@link incomplete}. */
 	readonly paths: ReadonlySet<string>;
+	/**
+	 * `true` when more paths changed than the accumulator retains, so {@link paths} is a partial set and a
+	 * miss does NOT mean the file is unchanged. Consumers testing membership must treat this as a match.
+	 */
+	readonly incomplete: boolean;
 }