@gitkraken/core-gitlens 0.24.0 → 0.26.0

package/dist/git/watching/worktreeSummary.js

@@ -20,6 +20,14 @@ const baseConfigField = 16;
 * the base's own ref just moved forward, it is re-measured rather than resolved again. {@link baseField} overrides it.
 */
 const baseMoveField = 32;
+/**
+* Checks the summary against what a probe finds now, for a change that may have moved one of its refs without naming it
+* (a packed-refs rewrite, a ref directory, an overflow or a poll): HEAD, the upstream and the counts against it as
+* `getBranch` answers them, and the refs the base depends on against the tips it was read from (see {@link ReadTips});
+* reads the groups that moved, as an unwatched read would — everything when HEAD's branch or commit did — and nothing
+* when none did
+*/
+const tipCheckField = 64;
 /** Every group a full read covers — a base read refreshes the {@link BaseKeys} snapshot itself */
 const allFields = 7;
 const maxConcurrentReadsPerRepository = 4;
@@ -27,6 +35,7 @@ const maxConcurrentReads = 8;
 const maxUnwatchedReads = 256;
 const maxDeferredDirtyMs = 1e4;
 const emptyRefs = Object.freeze([]);
+const noRemotes = /* @__PURE__ */ new Set();
 const noBaseKeys = [
 	void 0,
 	void 0,
@@ -125,9 +134,13 @@ var SummarySubscription = class {
 * inputs its last base read consulted (every branch's tracking but those of branches it didn't depend on), the stored
 * values, HEAD's commit or the upstream changed, unless it was confined to the
 * `branch.<name>` sections of branches the summary neither is on, tracks nor bases on (its `configBranches`), which
-* reads nothing; the checked-out branch moving, or a HEAD change, reads all of them. Stash, unrelated tags and
-* branches, and the like read nothing. One run is in flight per worktree at a time, at most four per repository (the
-* worktrees sharing a common git directory), and at most eight across the service. Runs take turns first come, first
+* reads nothing; the checked-out branch moving, or a HEAD change, reads all of them. A change that may have moved one
+* of those refs without naming it (a packed-refs rewrite, as deleting a packed branch makes, a ref directory, an
+* overflow or a poll) first checks HEAD, the upstream and the counts against it as core's cached `getBranch` answers
+* them, and the tips the base was read from against core's cached ref list, both shared by the repository's
+* checkouts, and reads only the groups that moved, by the same rules — nothing when none did.
+* Stash, unrelated tags and branches, and the like read nothing. One run is in flight per worktree at a time, at most
+* four per repository (the worktrees sharing a common git directory), and at most eight across the service. Runs take turns first come, first
 * served, except that one whose repository is at its cap lets later runs of other repositories go first, so a burst in
 * one repository never delays another's reads: events while a run waits for its turn join it, and events during a run
 * are merged into a single follow-up run.
@@ -370,13 +383,11 @@ var WorktreeSummaryService = class {
 	* the `HEAD` symrefs of `remotes` (every remote's when `undefined`); without `statIndex`, the index is unknown
 	*/
 	async probeUnwatched(repo, remotes, statIndex, signal) {
-		const remoteHeads = /* @__PURE__ */ new Map();
 		const stat = statIndex ? this.stat : void 0;
-		const [current, tips, gitDir] = await Promise.all([
+		const [current, refs, gitDir] = await Promise.all([
 			repo.branches.getBranch(void 0, void 0, signal),
-			repo.refs.getRefTips(void 0, signal),
-			stat != null ? getGitDir(repo) : void 0,
-			readRemoteHeads(repo, remoteHeads, remotes, signal)
+			probeRefs(repo, remotes, signal),
+			stat != null ? getGitDir(repo) : void 0
 		]);
 		let index;
 		if (stat != null && gitDir != null) try {
@@ -387,15 +398,59 @@ var WorktreeSummaryService = class {
 		}
 		const detached = current?.detached ?? false;
 		return {
+			current,
 			branch: detached ? void 0 : current?.name || void 0,
 			detached,
 			sha: current?.sha,
 			upstream: current?.upstream?.name,
-			tips: getTipsByName(tips),
-			remoteHeads,
+			tips: refs.tips,
+			remoteHeads: refs.remoteHeads,
 			index
 		};
 	}
+	/**
+	* A subscribed run's {@link ReadProbe}, from cached answers: HEAD when the branch is due or a tip check is, the ref
+	* tips (kept in `probed`), and the `HEAD` symrefs of the remotes the base depends on when the base may be read or a
+	* tip check is due — every remote's for a first read, which can come to depend on any. A tip check widens `fields` as
+	* {@link getTipCheckFields} finds, and is read in full when the probe fails; any other probe that fails leaves
+	* the tips its groups read unknown.
+	*/
+	async probeRead(repo, previous, tips, fields, baseMoves, probed, signal) {
+		const check = (fields & tipCheckField) !== 0 && previous != null && (fields & allFields) !== allFields;
+		fields &= -65;
+		const remotes = previous == null ? void 0 : check || (fields & 60) !== 0 ? getHeadRemotes(previous.baseDependsOn) : noRemotes;
+		try {
+			if (!check && (fields & branchField) === 0) {
+				probed.refs = await probeRefs(repo, remotes, signal);
+				return {
+					fields,
+					baseMoves
+				};
+			}
+			const probe = await this.probeUnwatched(repo, remotes, false, signal);
+			probed.refs = probe;
+			const head = { branch: probe.current };
+			if (!check) return {
+				fields,
+				baseMoves,
+				head
+			};
+			const moved = getTipCheckFields(probe, previous, tips);
+			if (moved.baseMoves != null && baseMoves != null) for (const ref of baseMoves) moved.baseMoves.add(ref);
+			return {
+				fields: fields | moved.fields,
+				baseMoves: moved.baseMoves ?? baseMoves,
+				head
+			};
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+			probed.refs = void 0;
+			return {
+				fields: check ? fields | allFields : fields,
+				baseMoves
+			};
+		}
+	}
 	getResourceUsage() {
 		return { "worktreeSummary.entries.count": this.entries.size };
 	}
@@ -424,6 +479,7 @@ var WorktreeSummaryService = class {
 			entry.baseKeys = last.result.baseKeys;
 			entry.baseConfigKey = last.result.baseConfigKey;
 			entry.baseDefaultBranch = last.result.baseDefaultBranch;
+			entry.tips = { base: last.inputs.baseTips };
 		} else entry.pending |= 23;
 		entry.handle = handle;
 		entry.slotsKey = getRepositoryKey(gitDir.commonUri ?? gitDir.uri);
@@ -501,17 +557,23 @@ var WorktreeSummaryService = class {
 		if (e.changed("index", "ignores")) fields |= dirtyField;
 		if (e.changed("config") && e.mayHaveChangedConfig(getConfigRelevantRefs(value))) fields |= 26;
 		if (e.changed("gkConfig")) fields |= baseKeysField;
-		if (value.branch != null && e.mayHaveChangedRef(`refs/heads/${value.branch}`)) fields |= allFields;
-		if (value.upstream != null && (e.mayHaveChangedRef(`refs/remotes/${value.upstream.name}`) || e.mayHaveChangedRef(`refs/heads/${value.upstream.name}`))) fields |= branchField;
+		if (value.branch != null) {
+			const ref = `refs/heads/${value.branch}`;
+			if (e.mayHaveChangedRef(ref)) fields |= isNamedRef(e, ref) ? allFields : tipCheckField;
+		}
+		if (value.upstream != null) {
+			const remoteRef = `refs/remotes/${value.upstream.name}`;
+			if (e.mayHaveChangedRef(remoteRef)) fields |= isNamedRef(e, remoteRef) ? branchField : tipCheckField;
+			const localRef = `refs/heads/${value.upstream.name}`;
+			if (e.mayHaveChangedRef(localRef)) fields |= isNamedRef(e, localRef) ? branchField : tipCheckField;
+		}
 		let baseMoves;
 		if ((fields & baseField) === 0) {
 			for (const ref of value.baseDependsOn) {
 				if (!e.mayHaveChangedRef(ref)) continue;
-				const kind = getRefChangeKind(ref);
-				if (!e.refs.has(ref) || kind == null || e.unnamedRefKinds.has(kind)) {
-					fields |= baseField;
-					baseMoves = void 0;
-					break;
+				if (!isNamedRef(e, ref)) {
+					fields |= tipCheckField;
+					continue;
 				}
 				baseMoves ??= [];
 				baseMoves.push(ref);
@@ -612,13 +674,16 @@ var WorktreeSummaryService = class {
 		return true;
 	}
 	async run(entry, fields, baseMoves) {
-		const { value, seed } = entry;
+		const { value, seed, tips } = entry;
 		const previous = value ?? seed;
+		if (previous?.stale) fields |= 23;
+		const probed = {};
 		let result;
 		try {
 			const repo = this.getRepository(entry.key);
 			if (repo == null) throw new Error(`No repository found for '${entry.key}'`);
-			result = await readSummary(repo, entry.key, fields, previous, entry.baseKeys, entry.baseConfigKey, entry.baseDefaultBranch, baseMoves, entry.abort.signal, this.verifyBaseRemeasure);
+			const signal = entry.abort.signal;
+			result = await readSummary(repo, entry.key, fields, previous, entry.baseKeys, entry.baseConfigKey, entry.baseDefaultBranch, baseMoves, signal, this.verifyBaseRemeasure, (due, moves) => this.probeRead(repo, previous, tips, due, moves, probed, signal));
 		} catch (ex) {
 			if (entry.disposed || isCancellationError(ex)) return;
 			this.fail(entry, ex);
@@ -628,6 +693,7 @@ var WorktreeSummaryService = class {
 		if (result.summary.stale && (previous == null || !previous.stale)) _logger.warn(`WorktreeSummaryService: reading the base of '${entry.key}' failed: ${String(result.baseError)}`);
 		entry.error = void 0;
 		entry.seed = void 0;
+		entry.tips = getReadTips(tips, probed.refs, result);
 		entry.baseKeys = result.baseKeys;
 		entry.baseConfigKey = entry.pending & baseConfigField ? void 0 : result.baseConfigKey;
 		entry.baseDefaultBranch = result.baseDefaultBranch;
@@ -687,6 +753,7 @@ var WorktreeSummaryService = class {
 		entry.baseKeys = void 0;
 		entry.baseConfigKey = void 0;
 		entry.baseDefaultBranch = void 0;
+		entry.tips = void 0;
 		entry.pending = 0;
 		entry.baseMoves = void 0;
 		entry.running = void 0;
@@ -709,6 +776,7 @@ function dropSeed(entry) {
 	entry.baseKeys = void 0;
 	entry.baseConfigKey = void 0;
 	entry.baseDefaultBranch = void 0;
+	entry.tips = void 0;
 }
 function clearDeferredDirty(entry) {
 	entry.dirtyReadAt = void 0;
@@ -730,6 +798,7 @@ function createEntry(key) {
 		baseKeys: void 0,
 		baseConfigKey: void 0,
 		baseDefaultBranch: void 0,
+		tips: void 0,
 		error: void 0,
 		pending: 0,
 		baseMoves: void 0,
@@ -747,7 +816,7 @@ function createEntry(key) {
 * answer. A failed base read doesn't fail the rest: the summary comes back stale, keeping the previous
 * base and `baseDependsOn` only while the branch is the same.
 */
-async function readSummary(repo, key, fields, previous, previousBaseKeys, previousBaseConfigKey, previousBaseDefaultBranch, baseMoves, signal, verifyBaseRemeasure) {
+async function readSummary(repo, key, fields, previous, previousBaseKeys, previousBaseConfigKey, previousBaseDefaultBranch, baseMoves, signal, verifyBaseRemeasure, probe) {
 	if (previous == null) fields |= allFields;
 	let dirtyReadAt;
 	const startDirtyRead = () => {
@@ -755,6 +824,12 @@ async function readSummary(repo, key, fields, previous, previousBaseKeys, previo
 		return readDirty(repo, signal);
 	};
 	let dirtyRead = fields & dirtyField ? startDirtyRead() : void 0;
+	let head;
+	if (probe != null && fields & 102) {
+		const probed = await probe(fields, baseMoves);
+		({fields, baseMoves, head} = probed);
+		if (fields & dirtyField) dirtyRead ??= startDirtyRead();
+	}
 	let branch = previous?.branch;
 	let detached = previous?.detached ?? false;
 	let sha = previous?.sha;
@@ -762,7 +837,7 @@ async function readSummary(repo, key, fields, previous, previousBaseKeys, previo
 	let ahead = previous?.ahead ?? 0;
 	let behind = previous?.behind ?? 0;
 	if (fields & branchField) {
-		const current = await repo.branches.getBranch(void 0, void 0, signal);
+		const current = head != null ? head.branch : await repo.branches.getBranch(void 0, void 0, signal);
 		detached = current?.detached ?? false;
 		branch = detached ? void 0 : current?.name || void 0;
 		sha = current?.sha;
@@ -867,7 +942,8 @@ async function readSummary(repo, key, fields, previous, previousBaseKeys, previo
 		baseConfigKey,
 		baseDefaultBranch,
 		baseError,
-		dirtyReadAt
+		dirtyReadAt,
+		fields
 	};
 }
 async function getGitDir(repo) {
@@ -878,6 +954,18 @@ async function getGitDir(repo) {
 		return;
 	}
 }
+/**
+* Reads the ref tips and the `HEAD` symrefs of `remotes` (every remote's when `undefined`), as core's caches answer
+* them: one ref list shared by the repository's worktrees
+*/
+async function probeRefs(repo, remotes, signal) {
+	const remoteHeads = /* @__PURE__ */ new Map();
+	const [tips] = await Promise.all([repo.refs.getRefTips(void 0, signal), readRemoteHeads(repo, remoteHeads, remotes, signal)]);
+	return {
+		tips: getTipsByName(tips),
+		remoteHeads
+	};
+}
 /** Each ref list's tips by full name, built once per list, which core's cache shares across a repository's worktrees */
 const tipsByNameCache = /* @__PURE__ */ new WeakMap();
 function getTipsByName(tips) {
@@ -901,14 +989,10 @@ async function getMovedFields(repo, last, probe, probeDirty, signal) {
 	const previous = last.result.summary;
 	if (probe.branch !== inputs.branch || probe.detached !== inputs.detached || probe.sha !== inputs.sha) fields |= allFields;
 	else {
+		fields |= getUpstreamFields(probe.current, previous);
 		if (probe.upstream !== inputs.upstream) fields |= 18;
 		else if (getUpstreamTips(probe.tips, probe.upstream) !== inputs.upstreamTips) fields |= branchField;
-		for (const ref of previous.baseDependsOn) {
-			const value = getBaseInput(probe, ref);
-			if (value !== null && value === inputs.baseTips.get(ref)) continue;
-			baseMoves ??= /* @__PURE__ */ new Set();
-			baseMoves.add(ref);
-		}
+		baseMoves = getMovedBaseRefs(probe, previous.baseDependsOn, inputs.baseTips);
 		if (baseMoves != null) fields |= baseMoveField;
 		if ((fields & baseConfigField) === 0 && last.result.baseConfigKey != null && repo.branches.getAheadOfBase != null && (probe.detached || probe.branch != null)) {
 			const configKey = getBaseConfigKey(await readBaseConfig(repo, signal), previous);
@@ -921,6 +1005,61 @@ async function getMovedFields(repo, last, probe, probeDirty, signal) {
 		baseMoves
 	};
 }
+/**
+* The read groups a tip check (see {@link tipCheckField}) finds moved since `previous` was read, with the refs the base
+* depends on as `tips` has them: everything when HEAD's branch or commit isn't the one `previous` has, else those
+* {@link getUpstreamFields} finds, and the base's refs that moved
+*/
+function getTipCheckFields(probe, previous, tips) {
+	if (probe.branch !== previous.branch || probe.detached !== previous.detached || probe.sha !== previous.sha) return {
+		fields: allFields,
+		baseMoves: void 0
+	};
+	let fields = getUpstreamFields(probe.current, previous);
+	const baseMoves = getMovedBaseRefs(probe, previous.baseDependsOn, tips?.base);
+	if (baseMoves != null) fields |= baseMoveField;
+	return {
+		fields,
+		baseMoves
+	};
+}
+/**
+* The read groups `current`, HEAD as `getBranch` answers it, finds moved in what `previous` has of the upstream: another
+* upstream reads the branch and the config inputs, which read the base again when the upstream's identity changed;
+* one gone or back, or other counts against it, the branch. Core drops its cached branches, counts and all, with its
+* ref list on any change to branches or remote-tracking refs, the changes a tip check follows, so a probe after one
+* answers them as of that change.
+*/
+function getUpstreamFields(current, previous) {
+	const upstream = current?.upstream;
+	if (upstream?.name !== previous.upstream?.name) return 18;
+	if (upstream?.missing !== previous.upstream?.missing || (upstream?.state.ahead ?? 0) !== previous.ahead || (upstream?.state.behind ?? 0) !== previous.behind) return branchField;
+	return 0;
+}
+/**
+* The refs of `baseDependsOn` that `probe` finds moved since `baseTips`; `undefined` when none did. A tip that's unknown
+* (`null`, or not kept) moved.
+*/
+function getMovedBaseRefs(probe, baseDependsOn, baseTips) {
+	let baseMoves;
+	for (const ref of baseDependsOn) {
+		const value = getBaseInput(probe, ref);
+		if (value !== null && baseTips?.has(ref) && value === baseTips.get(ref)) continue;
+		baseMoves ??= /* @__PURE__ */ new Set();
+		baseMoves.add(ref);
+	}
+	return baseMoves;
+}
+/**
+* The tips a subscribed run leaves its summary read from: from the refs its probe found (`refs`) when it read the base,
+* unknown when it read it without a probe, and else `last`'s
+*/
+function getReadTips(last, refs, result) {
+	const { summary, fields } = result;
+	let base = last?.base;
+	if (fields & 36) base = refs != null && !summary.stale ? getBaseTips(refs, summary.baseDependsOn) : void 0;
+	return { base };
+}
 /** The upstream's tips as a remote-tracking and as a local branch, since its short name doesn't say which */
 function getUpstreamTips(tips, upstream) {
 	if (upstream == null) return void 0;
@@ -973,18 +1112,22 @@ function getBaseInput(probe, ref) {
 }
 /** The inputs `summary` was read from, as the probe before its read found them */
 function toUnwatchedInputs(probe, summary) {
-	const baseTips = /* @__PURE__ */ new Map();
-	for (const ref of summary.baseDependsOn) baseTips.set(ref, getBaseInput(probe, ref));
 	return {
 		branch: probe.branch,
 		detached: probe.detached,
 		sha: probe.sha,
 		upstream: probe.upstream,
 		upstreamTips: getUpstreamTips(probe.tips, probe.upstream),
-		baseTips,
+		baseTips: getBaseTips(probe, summary.baseDependsOn),
 		index: probe.index
 	};
 }
+/** What `refs` found of each of `baseDependsOn` (see {@link getBaseInput}) */
+function getBaseTips(refs, baseDependsOn) {
+	const baseTips = /* @__PURE__ */ new Map();
+	for (const ref of baseDependsOn) baseTips.set(ref, getBaseInput(refs, ref));
+	return baseTips;
+}
 async function readBaseConfig(repo, signal) {
 	try {
 		if (repo.branches.getAheadOfBaseConfigEntries != null) return await repo.branches.getAheadOfBaseConfigEntries(signal);
@@ -1076,6 +1219,11 @@ async function toSummaryUpstream(repo, upstream, signal) {
 		missing
 	};
 }
+/** Whether `e` names `ref` exactly, so it's known to be a ref that moved rather than one that may have */
+function isNamedRef(e, ref) {
+	const kind = getRefChangeKind(ref);
+	return kind != null && e.refs.has(ref) && !e.unnamedRefKinds.has(kind);
+}
 function upstreamsEqual(a, b) {
 	return a === b || a != null && b != null && a.name === b.name && a.remote === b.remote && a.branch === b.branch && a.missing === b.missing;
 }