@gitkraken/core-gitlens 0.6.0 → 0.7.0

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

@@ -1,184 +0,0 @@
-import type { GitFile } from '../models/file.js';
-import type { GitPausedOperationStatus } from '../models/pausedOperationStatus.js';
-import type { GitReference } from '../models/reference.js';
-
-/**
- * Gets the ref for the incoming side of a conflict:
- * - rebase: REBASE_HEAD (the commit being applied)
- * - revert: parent of REVERT_HEAD (git's "theirs" in a revert is the state before the reverted commit)
- * - cherry-pick/merge: the operation-specific HEAD (CHERRY_PICK_HEAD, MERGE_HEAD)
- */
-export function getConflictIncomingRef(status: GitPausedOperationStatus): string | undefined {
-	if (status.type === 'rebase') return status.steps.current.commit?.ref ?? status.HEAD.ref;
-	if (status.type === 'revert') return `${status.HEAD.ref}^`;
-	return status.HEAD.ref;
-}
-
-/**
- * Gets the reference representing the "current" (ours/HEAD) side of the operation
- * For rebase, falls back to `onto` when no branch/tag points at the onto commit
- */
-export function getConflictCurrentRef(status: GitPausedOperationStatus): GitReference | undefined {
-	if (status.type === 'rebase') return status.current ?? status.onto;
-	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.
- *
- * Conflict files from `git status` don't carry `originalPath`, so we use diff status (from
- * `git diff --name-status -M`) to detect renames between the merge-base and each branch.
- *
- * Note: The diff status must NOT use a pathspec filter, because git applies pathspecs before
- * rename detection — so `git diff -M BASE HEAD -- new.ts` returns `A new.ts` instead of `R old.ts new.ts`
- * when the file was renamed from `old.ts`.
- *
- * @param currentFiles - Diff status from merge-base to my ref (e.g. merge-base..HEAD for current changes)
- * @param incomingFiles - Diff status from merge-base to the other ref (e.g. merge-base..incoming for current changes)
- * @param filePath - The file's current path in the working tree
- * @returns The resolved LHS path (at merge-base) and RHS path (at myRef)
- */
-export function resolveConflictFilePaths(
-	currentFiles: GitFile[] | undefined,
-	incomingFiles: GitFile[] | undefined,
-	filePath: string,
-): { lhsPath: string; rhsPath: string } {
-	// Check if the file was renamed between merge-base and my side
-	const currentRename = currentFiles?.find(
-		f => (f.status === 'R' || f.status === 'C') && f.path === filePath && f.originalPath,
-	);
-	if (currentRename?.originalPath) {
-		// My side renamed: merge-base has the original name, my side has the new name
-		return { lhsPath: currentRename.originalPath, rhsPath: filePath };
-	}
-
-	// Check if the other side renamed the file
-	if (incomingFiles != null) {
-		const incomingRename = incomingFiles.find(
-			f => (f.status === 'R' || f.status === 'C') && f.path === filePath && f.originalPath,
-		);
-		if (incomingRename?.originalPath) {
-			// Other side renamed: merge-base AND my side both have the original name
-			return { lhsPath: incomingRename.originalPath, rhsPath: incomingRename.originalPath };
-		}
-	}
-
-	// Fallback: git's rename detection can fail when the diff is large or the content similarity is
-	// below the threshold. Look for the add+delete pattern that indicates an undetected rename.
-
-	// Check if my side has an undetected rename (filePath added on my side, original path deleted)
-	if (currentFiles != null) {
-		const originalPath = findUndetectedRename(currentFiles, incomingFiles, filePath);
-		if (originalPath != null) {
-			return { lhsPath: originalPath, rhsPath: filePath };
-		}
-	}
-
-	// Check if other side has an undetected rename (filePath added on other side, original path deleted)
-	if (incomingFiles != null && currentFiles != null) {
-		const originalPath = findUndetectedRename(incomingFiles, currentFiles, filePath);
-		if (originalPath != null) {
-			return { lhsPath: originalPath, rhsPath: originalPath };
-		}
-	}
-
-	// No rename detected
-	return { lhsPath: filePath, rhsPath: filePath };
-}
-
-/**
- * Looks for an undetected rename in a diff: `filePath` was added on `sideFiles` and
- * a corresponding path was deleted on `sideFiles` while being present in `otherSideFiles`.
- *
- * Git's `-M` rename detection can fail when there are many files (exceeding `diff.renameLimit`)
- * or when content similarity is below the threshold. In those cases, git reports the rename as
- * separate `A` (add) and `D` (delete) entries. This function matches those pairs.
- *
- * @returns The original (deleted) path, or undefined if no match.
- */
-function findUndetectedRename(
-	sideFiles: GitFile[],
-	otherSideFiles: GitFile[] | undefined,
-	filePath: string,
-): string | undefined {
-	// Verify filePath was added on this side (not renamed — that was already checked)
-	if (!sideFiles.some(f => f.status === 'A' && f.path === filePath)) return undefined;
-
-	// Find a deleted file on this side that the other side also references.
-	// Use path-suffix matching to disambiguate: renames that add a directory prefix (e.g. monorepo
-	// migrations moving `src/x.ts` → `packages/utils/src/x.ts`) produce a pair where one path
-	// is a suffix of the other at a directory boundary.
-	const fileName = filePath.substring(filePath.lastIndexOf('/') + 1);
-	let fallbackMatch: string | undefined;
-	for (const deleted of sideFiles) {
-		if (deleted.status !== 'D') continue;
-
-		// The other side must have an entry for the deleted path (confirming it's a real file both sides know about)
-		if (otherSideFiles != null && !otherSideFiles.some(f => f.path === deleted.path)) continue;
-
-		// Prefer suffix match (strong signal): one path ends with the other at a directory boundary
-		if (filePath.endsWith(`/${deleted.path}`) || deleted.path.endsWith(`/${filePath}`)) {
-			return deleted.path;
-		}
-
-		// Only consider same-basename files as a weaker fallback (catches renames where directory
-		// structure changed significantly, e.g. `src/git/parsers/x.ts` → `packages/cli/src/parsers/x.ts`)
-		if (fallbackMatch == null && deleted.path.substring(deleted.path.lastIndexOf('/') + 1) === fileName) {
-			fallbackMatch = deleted.path;
-		}
-	}
-
-	return fallbackMatch;
-}

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

@@ -1,244 +0,0 @@
-import type {
-	PullRequest,
-	PullRequestComparisonRefs,
-	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;
-
-	ownerAndRepo?: string;
-	prNumber: string;
-}
-
-export function getComparisonRefsForPullRequest(repoPath: string, prRefs: PullRequestRefs): PullRequestComparisonRefs {
-	const refs: PullRequestComparisonRefs = {
-		repoPath: repoPath,
-		base: { ref: prRefs.base.sha, label: `${prRefs.base.branch} (${shortenRevision(prRefs.base.sha)})` },
-		head: { ref: prRefs.head.sha, label: prRefs.head.branch },
-	};
-	return refs;
-}
-
-export function getPullRequestIdentityFromMaybeUrl(search: string): PullRequestUrlIdentity | undefined {
-	let prNumber: string | undefined = undefined;
-
-	let match = search.match(/(?:\/)(\d+)/); // any number starting with "/"
-	if (match != null) {
-		prNumber = match[1];
-	}
-
-	if (prNumber == null) {
-		match = search.match(/^#?(\d+)$/); // just a number or with a leading "#"
-		if (match != null) {
-			prNumber = match[1];
-		}
-	}
-
-	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,
-): PullRequestRepositoryIdentityDescriptor {
-	if (headRepo) {
-		return {
-			remote: {
-				url: pr.refs?.head?.url,
-				domain: pr.provider.domain,
-			},
-			name: `${pr.refs?.head?.owner ?? pr.repository.owner}/${pr.refs?.head?.repo ?? pr.repository.repo}`,
-			provider: {
-				id: pr.provider.id,
-				domain: pr.provider.domain,
-				repoDomain: pr.refs?.head?.owner ?? pr.repository.owner,
-				repoName: pr.refs?.head?.repo ?? pr.repository.repo,
-			},
-		};
-	}
-
-	return {
-		remote: {
-			url: pr.refs?.base?.url ?? pr.url,
-			domain: pr.provider.domain,
-		},
-		name: `${pr.refs?.base?.owner ?? pr.repository.owner}/${pr.refs?.base?.repo ?? pr.repository.repo}`,
-		provider: {
-			id: pr.provider.id,
-			domain: pr.provider.domain,
-			repoDomain: pr.refs?.base?.owner ?? pr.repository.owner,
-			repoName: pr.refs?.base?.repo ?? pr.repository.repo,
-			repoOwnerDomain: pr.refs?.base?.owner ?? pr.repository.owner,
-		},
-	};
-}
-
-export function isMaybeNonSpecificPullRequestSearchUrl(search: string): boolean {
-	return getPullRequestIdentityFromMaybeUrl(search) != null;
-}
-
-export function serializePullRequest(value: PullRequest): PullRequestShape {
-	const serialized: PullRequestShape = {
-		type: value.type,
-		provider: {
-			id: value.provider.id,
-			name: value.provider.name,
-			domain: value.provider.domain,
-			icon: value.provider.icon,
-		},
-		id: value.id,
-		nodeId: value.nodeId,
-		number: value.number,
-		title: value.title,
-		body: value.body,
-		url: value.url,
-		createdDate: value.createdDate,
-		updatedDate: value.updatedDate,
-		closedDate: value.closedDate,
-		closed: value.closed,
-		author: {
-			id: value.author.id,
-			name: value.author.name,
-			username: value.author.username,
-			avatarUrl: value.author.avatarUrl,
-			url: value.author.url,
-		},
-		state: value.state,
-		mergedDate: value.mergedDate,
-		mergeableState: value.mergeableState,
-		refs: value.refs
-			? {
-					head: {
-						exists: value.refs.head.exists,
-						owner: value.refs.head.owner,
-						repo: value.refs.head.repo,
-						sha: value.refs.head.sha,
-						branch: value.refs.head.branch,
-						url: value.refs.head.url,
-						cloneHttps: value.refs.head.cloneHttps,
-						cloneSsh: value.refs.head.cloneSsh,
-						isFork: value.refs.head.isFork,
-					},
-					base: {
-						exists: value.refs.base.exists,
-						owner: value.refs.base.owner,
-						repo: value.refs.base.repo,
-						sha: value.refs.base.sha,
-						branch: value.refs.base.branch,
-						url: value.refs.base.url,
-						cloneHttps: value.refs.base.cloneHttps,
-						cloneSsh: value.refs.base.cloneSsh,
-						isFork: value.refs.base.isFork,
-					},
-					isCrossRepository: value.refs.isCrossRepository,
-				}
-			: undefined,
-		isDraft: value.isDraft,
-		additions: value.additions,
-		deletions: value.deletions,
-		commentsCount: value.commentsCount,
-		thumbsUpCount: value.thumbsUpCount,
-		reviewDecision: value.reviewDecision,
-		reviewRequests: value.reviewRequests,
-		latestReviews: value.latestReviews,
-		assignees: value.assignees,
-		authoredByMe: value.authoredByMe,
-		project: value.project
-			? {
-					id: value.project.id,
-					name: value.project.name,
-					resourceId: value.project.resourceId,
-					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/utils/reachability.utils.ts

@@ -1,180 +0,0 @@
-import { base64, fromBase64 } from '../../utils/base64.js';
-import type { GraphContext, GraphReachabilityTable } from '../models/graph.js';
-import { GitGraphRowContextFlags } from '../models/graph.js';
-import type { GitCommitReachability } from '../providers/commits.js';
-
-type ReachableRef = GitCommitReachability['refs'][number];
-
-/**
- * Computes the compact {@link GitGraphRowContextFlags} bitfield for a commit row from its reachable-ref
- * set and the walk's HEAD-derived sets. Single-sourced so the host row processor
- * (`GlGraphRowProcessor`), the R6b incremental fast path, and the equivalence harness all compute
- * byte-identical flags (no manual mirrors that can drift). Stash rows carry no flags — callers skip this
- * for `stash` rows. See {@link GitGraphRowContextFlags} for the per-bit semantics.
- */
-export function computeGraphRowContextFlags(
-	sha: string,
-	reachableRefs: Iterable<ReachableRef> | undefined,
-	ctx: Pick<
-		GraphContext,
-		'reachableFromHEAD' | 'rewriteableFromHEAD' | 'tipShasWithChildren' | 'reachableFromHeadUpstream'
-	>,
-): GitGraphRowContextFlags {
-	// Allocation-free "exactly one local branch reachable" check → `+unique`.
-	let localBranches = 0;
-	if (reachableRefs != null) {
-		for (const r of reachableRefs) {
-			if (r.refType === 'branch' && !r.remote && ++localBranches > 1) break;
-		}
-	}
-	// Unpublished (ahead) = reachable from HEAD but not from HEAD's upstream tip. Unpulled (behind) is its
-	// exact mirror over the same two sets: on the upstream tip but not on HEAD, i.e. `HEAD..@{u}`. Both are
-	// derived from `reachableFromHeadUpstream`, which is undefined when HEAD has no upstream — so neither
-	// is ever flagged in that case, and the two can never both be set for one sha.
-	const upstream = ctx.reachableFromHeadUpstream;
-	const reachableFromHead = ctx.reachableFromHEAD.has(sha);
-	const onUpstream = upstream?.has(sha) ?? false;
-	const isUnpublished = upstream != null && reachableFromHead && !onUpstream;
-	const isUnpulled = onUpstream && !reachableFromHead;
-	return (
-		(reachableFromHead ? GitGraphRowContextFlags.ReachableFromHead : 0) |
-		(ctx.rewriteableFromHEAD.has(sha) ? GitGraphRowContextFlags.RewriteableFromHead : 0) |
-		(localBranches === 1 ? GitGraphRowContextFlags.UniqueToBranch : 0) |
-		(ctx.tipShasWithChildren.has(sha) ? GitGraphRowContextFlags.HasChildren : 0) |
-		(isUnpublished ? GitGraphRowContextFlags.Unpublished : 0) |
-		(isUnpulled ? GitGraphRowContextFlags.Unpulled : 0)
-	);
-}
-
-/**
- * Canonical dictionary key for a reachable ref. The `r`/`l` discriminator keeps a remote branch from
- * colliding with a local branch of the same name; the `refType` prefix separates tags from branches.
- * `current` is part of the key so a builder SEEDED from a prior generation's table can't hand back a
- * stale dictionary entry after the checked-out branch changes — the updated ref interns as a new
- * entry instead (within a single walk `current` can't change, so the wider key is behavior-neutral).
- * Single-sourced here so the encoder ({@link createReachabilityTableBuilder}) and any future consumer
- * can't drift on the convention.
- */
-export function reachableRefKey(ref: ReachableRef): string {
-	return `${ref.refType}:${ref.refType === 'branch' && ref.remote ? 'r' : 'l'}:${ref.current ? 'c' : 'n'}:${ref.name}`;
-}
-
-// Monotonic generation counter — each builder (i.e. each fresh graph walk) gets a distinct id, while a
-// builder reused across `more()` pagination keeps its id. Only ever incremented host-side (the encoder);
-// the webview treats the id as opaque. Module-scoped so ids are unique across a session's builders.
-let nextReachabilityTableId = 0;
-
-/**
- * Builds a {@link GraphReachabilityTable} incrementally: interns refs into a shared dictionary and
- * distinct membership bitmaps into a deduplicated set list. Kept next to {@link decodeReachabilitySet}
- * (its exact inverse) so the wire format — first-seen dictionary indexing, LSB-first bit packing,
- * base64 — has a single owner and a round-trippable test, rather than an encoder and decoder that can
- * silently diverge across packages.
- *
- * Append-only by construction: an index, once assigned, is never reused — so a builder kept alive
- * across paginated loads accumulates a table whose existing indices stay valid as it grows.
- *
- * Pass a prior generation's table as `seed` to CONTINUE it: identical ref sets re-intern to their
- * seeded indices and the table keeps the seed's `id`, so rows retained across a rebuild keep valid
- * `reachabilityIndex` values and the host's same-id delta shipping applies (only appended entries go
- * over the wire). Entries the new walk never re-interns stay in the table unreferenced — harmless,
- * and bounded by per-session ref churn.
- */
-export function createReachabilityTableBuilder(seed?: GraphReachabilityTable): {
-	intern: (refs: Iterable<ReachableRef> | undefined) => number | undefined;
-	build: () => GraphReachabilityTable | undefined;
-} {
-	const id = seed?.id ?? ++nextReachabilityTableId;
-	const dictionary: GitCommitReachability['refs'] = seed != null ? [...seed.dictionary] : [];
-	const refKeyToIndex = new Map<string, number>(dictionary.map((ref, i) => [reachableRefKey(ref), i]));
-	const sets: string[] = seed != null ? [...seed.sets] : [];
-	const setKeyToIndex = new Map<string, number>(sets.map((encoded, i) => [encoded, i]));
-
-	// Reachability is monotone, so a graph walk interns long runs of IDENTICAL sets (thousands of
-	// consecutive trunk rows share one set). Remembering the previous call's indices skips the
-	// bitmap-pack + base64 for those runs; a same-membership-different-order call just falls through
-	// to the (still correct) slow path.
-	let lastIndices: number[] | undefined;
-	let lastSetIndex: number | undefined;
-
-	return {
-		/** Interns a ref set, returning its index into `sets`, or undefined when the set is empty. */
-		intern: (refs: Iterable<ReachableRef> | undefined): number | undefined => {
-			if (refs == null) return undefined;
-
-			let maxIndex = -1;
-			const indices: number[] = [];
-			for (const ref of refs) {
-				const key = reachableRefKey(ref);
-				let index = refKeyToIndex.get(key);
-				if (index == null) {
-					index = dictionary.length;
-					refKeyToIndex.set(key, index);
-					dictionary.push(ref);
-				}
-				indices.push(index);
-				if (index > maxIndex) {
-					maxIndex = index;
-				}
-			}
-			if (indices.length === 0) return undefined;
-
-			if (lastIndices != null && indices.length === lastIndices.length) {
-				let same = true;
-				for (let i = 0; i < indices.length; i++) {
-					if (indices[i] !== lastIndices[i]) {
-						same = false;
-						break;
-					}
-				}
-				if (same) return lastSetIndex;
-			}
-
-			// Pack into a bitset sized to this set's high-water dictionary index, then intern by base64.
-			const bytes = new Uint8Array((maxIndex >> 3) + 1);
-			for (const index of indices) {
-				bytes[index >> 3] |= 1 << (index & 7);
-			}
-			const encoded = base64(bytes);
-			let setIndex = setKeyToIndex.get(encoded);
-			if (setIndex == null) {
-				setIndex = sets.length;
-				setKeyToIndex.set(encoded, setIndex);
-				sets.push(encoded);
-			}
-			lastIndices = indices;
-			lastSetIndex = setIndex;
-			return setIndex;
-		},
-
-		/** The accumulated table, or undefined when nothing was interned. */
-		build: (): GraphReachabilityTable | undefined =>
-			dictionary.length ? { id: id, dictionary: dictionary, sets: sets } : undefined,
-	};
-}
-
-/**
- * Decodes the membership bitmap at `index` in a {@link GraphReachabilityTable} back into its list of
- * reachable refs. Refs come back in the table's first-seen dictionary order — callers that need the
- * canonical display order (current-first / local-before-remote / tags newest-first) sort the result
- * with `compareReachableRefs`. Returns an empty array for an out-of-range/missing set index.
- *
- * The bitmap is at most `ceil(dictionary.length / 8)` bytes; earlier (shorter) bitmaps packed against
- * a smaller dictionary stay valid — only bits actually present can be set, so the loop stops at the
- * shorter of the dictionary length and the bitmap's bit count rather than scanning a guaranteed-zero tail.
- */
-export function decodeReachabilitySet(table: GraphReachabilityTable, index: number): GitCommitReachability['refs'] {
-	const { dictionary, sets } = table;
-	const encoded = sets[index];
-	if (encoded == null) return [];
-
-	const bytes = fromBase64(encoded);
-	const refs: GitCommitReachability['refs'] = [];
-	const count = Math.min(dictionary.length, bytes.length * 8);
-	for (let i = 0; i < count; i++) {
-		if ((bytes[i >> 3] ?? 0) & (1 << (i & 7))) {
-			refs.push(dictionary[i]);
-		}
-	}
-	return refs;
-}