@gitkraken/core-gitlens 0.16.5 → 0.18.0

package/dist/git/watching/worktreeSummary.js

@@ -3,7 +3,9 @@ import { CancellationError, isCancellationError, raceWithSignal } from "../../ut
 import { Logger as _logger } from "../../utils/logger.js";
 import { Emitter } from "../../utils/event.js";
 import { getRepositoryKey } from "../../utils/uri.js";
+import { joinPaths } from "../../utils/path.js";
 import { getRefChangeKind } from "./changeEvent.js";
+import { LruMap } from "../../utils/lruMap.js";
 //#region ../git/src/watching/worktreeSummary.ts
 /** Read groups, as bit flags so a pending set is a number rather than an allocation per event */
 const dirtyField = 1;
@@ -22,12 +24,33 @@ const baseMoveField = 32;
 const allFields = 7;
 const maxConcurrentReadsPerRepository = 4;
 const maxConcurrentReads = 8;
+const maxUnwatchedReads = 256;
+const maxDeferredDirtyMs = 1e4;
 const emptyRefs = Object.freeze([]);
 const noBaseKeys = [
 	void 0,
 	void 0,
 	void 0
 ];
+/** A read of a worktree without a subscription, which concurrent callers share */
+var UnwatchedFlight = class {
+	key;
+	probeDirty;
+	disposed;
+	abort = new AbortController();
+	/** Callers waiting for it; the read is aborted once none is */
+	callers = 0;
+	/** Read groups made due while it ran, carried into what it stores */
+	due = 0;
+	promise;
+	constructor(key, probeDirty, disposed, read) {
+		this.key = key;
+		this.probeDirty = probeDirty;
+		this.disposed = disposed;
+		this.promise = Promise.resolve().then(() => read(this));
+		this.promise.catch(noop);
+	}
+};
 var SummarySubscription = class {
 	entry;
 	options;
@@ -44,6 +67,9 @@ var SummarySubscription = class {
 	get current() {
 		return this.disposed ? void 0 : this.entry.value;
 	}
+	get dirtyReadAt() {
+		return this.disposed || this.entry.value == null ? void 0 : this.entry.dirtyReadAt;
+	}
 	get onDidChange() {
 		return this.emitter.event;
 	}
@@ -79,7 +105,10 @@ var SummarySubscription = class {
 * has working changes, and how far it is past its base — kept current by the repository watch layer.
 *
 * **Lifecycle.** Entries are per repository key and ref-counted across {@link subscribe} calls. The first subscriber
-* starts watching the worktree and reads everything; the last one to leave aborts any in-flight read, releases the
+* starts watching the worktree and reads everything, or, for a worktree last read without a subscription, starts from
+* that read: it re-reads the groups whose inputs moved since, by the same rules as such a read, and always `dirty` —
+* unless its working-tree watch is still starting, when the rescan that watch owes reads it, and the summary keeps the
+* saved read's flag, with its `dirtyReadAt`, until then. The last one to leave aborts any in-flight read, releases the
 * watch and drops the value. Each subscriber's timing options join the watch session's cadence (the shortest wins);
 * the service's own listening subscriptions never constrain it.
 *
@@ -106,11 +135,27 @@ var SummarySubscription = class {
 * **Value-change-only notification.** {@link WorktreeSummarySubscription.onDidChange} and {@link onDidChangeSummary}
 * fire only when some field's value differs from the previous summary — a recompute that reads the same answer is
 * silent, so a consumer can re-render on every event without diffing. A failed recompute keeps the last values and
-* sets `stale` (firing once); the next successful one clears it.
+* sets `stale` (firing once); the next successful one clears it. A summary still showing the dirty flag of a read
+* without a subscription fires again, unchanged, once that flag is read again (its `dirtyReadAt` cleared).
+*
+* **Worktrees without a subscription.** {@link getSummary} and {@link getSummarySnapshot} answer one from its last read
+* (kept for the {@link maxUnwatchedReads} most recently asked), re-reading only the groups whose inputs moved since:
+* HEAD's branch or commit reads all of them; the upstream's tip, or its name, reads `branch`; a ref the base depends on
+* (where a remote's `HEAD` symref points, for one) reads `base`, re-measured from the previous one where that can
+* answer; the config inputs its base read consulted read `branch` and the base when they changed; and the worktree's
+* index file reads `dirty`. The inputs come from core's caches, so nothing moved means no git at all; only a `.git`
+* watch of the worktree (or core's own writes) keeps them current, so a host must watch the `.git` of a worktree it
+* asks about this way for others' changes to show. Its working tree is unwatched, so an edit that leaves the index
+* alone goes unseen until `dirty` is read again: the snapshot says when that was, and `probeDirty` reads it anyway.
+* Concurrent reads of a worktree share one, and take no read slot: each is a caller's foreground read, which never
+* waits behind subscribed worktrees' runs. A first subscriber takes over the last read.
 */
 var WorktreeSummaryService = class {
 	_onDidChangeSummary = new Emitter();
-	/** Fires when the summary of any subscribed worktree changes value */
+	/**
+	* Fires when the summary of any subscribed worktree changes value, and with the same summary when a dirty flag kept
+	* from a read without a subscription is read again (see {@link WorktreeSummarySubscription.dirtyReadAt})
+	*/
 	get onDidChangeSummary() {
 		return this._onDidChangeSummary.event;
 	}
@@ -120,9 +165,14 @@ var WorktreeSummaryService = class {
 	activeReads = 0;
 	/** Entries waiting for a read slot, oldest first */
 	readWaiters = /* @__PURE__ */ new Map();
+	/** The last read of each worktree without a subscription, by repository key */
+	unwatchedReads = new LruMap(maxUnwatchedReads);
+	/** The read in flight for each worktree without a subscription, by repository key */
+	unwatchedFlights = /* @__PURE__ */ new Map();
 	watchService;
 	getRepository;
 	getCommonPath;
+	stat;
 	verifyBaseRemeasure;
 	mergeTargetsListener;
 	_disposed = false;
@@ -130,6 +180,7 @@ var WorktreeSummaryService = class {
 		this.watchService = options.watchService;
 		this.getRepository = options.getRepository;
 		this.getCommonPath = options.getCommonPath;
+		this.stat = options.stat;
 		this.verifyBaseRemeasure = options.verifyBaseRemeasure;
 		this.mergeTargetsListener = options.onDidChangeMergeTargets?.((e) => this.onMergeTargetsChanged(e));
 	}
@@ -141,12 +192,22 @@ var WorktreeSummaryService = class {
 		this._disposed = true;
 		for (const resolve of this.readWaiters.values()) resolve(false);
 		this.readWaiters.clear();
+		for (const flight of this.unwatchedFlights.values()) {
+			flight.disposed = true;
+			flight.abort.abort();
+		}
+		this.unwatchedFlights.clear();
+		this.unwatchedReads.clear();
 		this.mergeTargetsListener?.dispose();
 		for (const entry of [...this.entries.values()]) for (const subscription of [...entry.subscribers]) subscription.dispose();
 		this.entries.clear();
 		this._onDidChangeSummary.dispose();
 	}
-	/** Subscribes to a worktree's summary, starting to watch and read it if this is its first subscriber */
+	/**
+	* Subscribes to a worktree's summary, starting to watch and read it if this is its first subscriber: from its last
+	* read without a subscription, if any, re-reading the groups whose inputs moved since and the dirty flag — at once,
+	* or, while its working-tree watch is still starting, as that watch goes live
+	*/
 	subscribe(repoPath, options) {
 		const key = getRepositoryKey(repoPath);
 		let entry = this._disposed ? void 0 : this.entries.get(key);
@@ -161,33 +222,179 @@ var WorktreeSummaryService = class {
 		target.subscribers.add(subscription);
 		if (isNew) {
 			if (!target.disposed) {
-				target.pending = 23;
+				this.unwatchedFlights.delete(key);
 				target.running = this.start(target);
 			}
 		} else if (target.handle != null) subscription.attach(target.handle.session);
-		else if (target.running == null && !target.disposed) {
-			target.pending = 23;
-			target.running = this.start(target);
-		}
+		else if (target.running == null && !target.disposed) target.running = this.start(target);
 		return subscription;
 	}
 	/**
 	* Returns a worktree's summary. For a subscribed worktree, the cached value — after waiting for any run in flight
-	* or pending; it rejects with the read's error when there is still no value. Otherwise a one-off full read that
-	* is neither cached nor watched.
+	* or pending; it rejects with the read's error when there is still no value. Otherwise the last read of it,
+	* re-reading what moved since (see {@link getSummarySnapshot}).
 	*/
 	async getSummary(repoPath, cancellation) {
 		const key = getRepositoryKey(repoPath);
 		const entry = this.entries.get(key);
-		if (entry == null) {
-			const repo = this.getRepository(key);
-			if (repo == null) throw new Error(`No repository found for '${key}'`);
-			return (await readSummary(repo, key, allFields, void 0, void 0, void 0, void 0, void 0, cancellation, this.verifyBaseRemeasure)).summary;
+		if (entry == null) return (await this.getUnwatchedSnapshot(key, false, cancellation)).summary;
+		return this.getSubscribedSummary(entry, cancellation);
+	}
+	/**
+	* Returns a worktree's summary, with when its dirty flag was read. A subscribed worktree answers as
+	* {@link getSummary} does, with `dirtyReadAt` `undefined` once its summary follows its working tree, and until then
+	* the saved read's (see {@link WorktreeSummarySubscription.dirtyReadAt}), which `probeDirty` reads again. Any other
+	* answers from its last read, re-reading only the groups whose inputs moved since (no git when none did), and in
+	* full the first time, or after a failed or stale read. Its working tree is unwatched, so the dirty flag is re-read
+	* only when the index file moved, or with `probeDirty`; a rejection drops the last read. Its inputs are core's
+	* cached answers, which only a `.git` watch of the worktree (or core's own writes) keeps current.
+	*/
+	async getSummarySnapshot(repoPath, options) {
+		const key = getRepositoryKey(repoPath);
+		const entry = this.entries.get(key);
+		if (entry == null) return this.getUnwatchedSnapshot(key, options?.probeDirty ?? false, options?.cancellation);
+		return this.getSubscribedSnapshot(entry, options?.probeDirty ?? false, options?.cancellation);
+	}
+	async getSubscribedSnapshot(entry, probeDirty, cancellation) {
+		let summary = await this.getSubscribedSummary(entry, cancellation);
+		if (probeDirty && entry.dirtyReadAt != null) {
+			this.queue(entry, dirtyField);
+			summary = await this.getSubscribedSummary(entry, cancellation);
 		}
+		return {
+			summary,
+			dirtyReadAt: entry.dirtyReadAt
+		};
+	}
+	async getSubscribedSummary(entry, cancellation) {
 		if (entry.running != null) await (cancellation != null ? raceWithSignal(entry.running, cancellation) : entry.running);
 		if (entry.disposed) throw new CancellationError();
 		if (entry.value != null) return entry.value;
-		throw entry.error ?? /* @__PURE__ */ new Error(`No summary available for '${key}'`);
+		throw entry.error ?? /* @__PURE__ */ new Error(`No summary available for '${entry.key}'`);
+	}
+	/** Joins the read in flight for `key`, or starts one; the read is aborted only once no caller waits for it */
+	async getUnwatchedSnapshot(key, probeDirty, cancellation) {
+		if (cancellation?.aborted) throw new CancellationError();
+		let flight = this.getJoinableFlight(key);
+		if (probeDirty) {
+			while (flight != null && !flight.probeDirty) {
+				const waited = flight;
+				try {
+					await (cancellation != null ? raceWithSignal(waited.promise, cancellation) : waited.promise);
+				} catch (ex) {
+					if (cancellation?.aborted) throw ex;
+				}
+				flight = this.getJoinableFlight(key);
+				if (flight === waited) flight = void 0;
+			}
+			const entry = this.entries.get(key);
+			if (entry != null) return this.getSubscribedSnapshot(entry, true, cancellation);
+		}
+		if (flight == null) {
+			flight = new UnwatchedFlight(key, probeDirty, this._disposed, (f) => this.readUnwatched(f));
+			if (!this._disposed) this.unwatchedFlights.set(key, flight);
+		}
+		const current = flight;
+		current.callers++;
+		try {
+			const read = await (cancellation != null ? raceWithSignal(current.promise, cancellation) : current.promise);
+			return {
+				summary: read.result.summary,
+				dirtyReadAt: read.dirtyReadAt
+			};
+		} finally {
+			current.callers--;
+			if (current.callers === 0) {
+				if (this.unwatchedFlights.get(key) === current) this.unwatchedFlights.delete(key);
+				current.disposed = true;
+				current.abort.abort();
+			}
+		}
+	}
+	/**
+	* The read in flight for `key`, unless core wrote a merge target or base while it ran: it may have read the stored
+	* values before the write, and a caller after an awaited write sees them, as one of a subscribed worktree does
+	*/
+	getJoinableFlight(key) {
+		const flight = this.unwatchedFlights.get(key);
+		return flight?.due === 0 ? flight : void 0;
+	}
+	async readUnwatched(flight) {
+		const { key } = flight;
+		const signal = flight.abort.signal;
+		if (flight.disposed) throw new CancellationError();
+		let last = this.unwatchedReads.get(key);
+		if (last?.result.summary.stale) last = void 0;
+		try {
+			const repo = this.getRepository(key);
+			if (repo == null) throw new Error(`No repository found for '${key}'`);
+			const headRemotes = last != null ? getHeadRemotes(last.result.summary.baseDependsOn) : void 0;
+			const probe = await this.probeUnwatched(repo, headRemotes, true, signal);
+			if (flight.disposed) throw new CancellationError();
+			let fields;
+			let baseMoves;
+			if (last == null) fields = 23;
+			else {
+				({fields, baseMoves} = await getMovedFields(repo, last, probe, flight.probeDirty, signal));
+				if (flight.disposed) throw new CancellationError();
+				if (fields === 0) {
+					this.unwatchedReads.touch(key);
+					return last;
+				}
+			}
+			if (headRemotes != null && (fields & 60) !== 0) {
+				await readRemoteHeads(repo, probe.remoteHeads, void 0, signal);
+				if (flight.disposed) throw new CancellationError();
+			}
+			let result = await readSummary(repo, key, fields, last?.result.summary, last?.result.baseKeys, last?.result.baseConfigKey, last?.result.baseDefaultBranch, baseMoves, signal, this.verifyBaseRemeasure);
+			const kept = last?.result.summary;
+			if (kept != null && summariesEqual(kept, result.summary)) result = {
+				...result,
+				summary: kept
+			};
+			const read = {
+				result,
+				dirtyReadAt: result.dirtyReadAt ?? last?.dirtyReadAt ?? Date.now(),
+				inputs: toUnwatchedInputs(probe, result.summary),
+				due: flight.due
+			};
+			if (this.unwatchedFlights.get(key) === flight && !this.entries.has(key)) this.unwatchedReads.set(key, read);
+			return read;
+		} catch (ex) {
+			if (!isCancellationError(ex) && this.unwatchedFlights.get(key) === flight) this.unwatchedReads.delete(key);
+			throw ex;
+		}
+	}
+	/**
+	* Reads an unwatched read's inputs: cached answers but for the index file's stat (see {@link UnwatchedInputs}), with
+	* 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([
+			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)
+		]);
+		let index;
+		if (stat != null && gitDir != null) try {
+			const stats = await stat(joinPaths(gitDir.uri.fsPath, "index"));
+			index = stats != null ? `${stats.size}:${stats.mtime}` : "";
+		} catch {
+			index = void 0;
+		}
+		const detached = current?.detached ?? false;
+		return {
+			branch: detached ? void 0 : current?.name || void 0,
+			detached,
+			sha: current?.sha,
+			upstream: current?.upstream?.name,
+			tips: getTipsByName(tips),
+			remoteHeads,
+			index
+		};
 	}
 	getResourceUsage() {
 		return { "worktreeSummary.entries.count": this.entries.size };
@@ -209,6 +416,15 @@ var WorktreeSummaryService = class {
 			this.fail(entry, /* @__PURE__ */ new Error(`Unable to watch '${entry.key}': no repository or git directory`));
 			return;
 		}
+		let last = this.unwatchedReads.get(entry.key);
+		this.unwatchedReads.delete(entry.key);
+		if (last?.result.summary.stale) last = void 0;
+		if (last != null) {
+			entry.seed = last.result.summary;
+			entry.baseKeys = last.result.baseKeys;
+			entry.baseConfigKey = last.result.baseConfigKey;
+			entry.baseDefaultBranch = last.result.baseDefaultBranch;
+		} else entry.pending |= 23;
 		entry.handle = handle;
 		entry.slotsKey = getRepositoryKey(gitDir.commonUri ?? gitDir.uri);
 		const session = handle.session;
@@ -227,10 +443,56 @@ var WorktreeSummaryService = class {
 			workingTreeSub
 		];
 		for (const subscription of entry.subscribers) subscription.attach(session);
+		if (last != null) {
+			await this.queueSeedStart(entry, last, this.watchService.isWorkingTreeStarting(entry.key));
+			if (entry.disposed) return;
+		}
 		await this.drain(entry);
 	}
+	/**
+	* Queues the groups of the saved read `last` whose inputs moved since, as an unwatched read finds them, and the
+	* dirty flag, which no input vouches for; everything when its inputs can't be read. With `deferDirty`, the dirty
+	* flag is left to the rescan of a working-tree watch still starting, and the value keeps `last`'s until then
+	*/
+	async queueSeedStart(entry, last, deferDirty) {
+		const signal = entry.abort.signal;
+		let moved;
+		try {
+			const repo = this.getRepository(entry.key);
+			if (repo != null) {
+				const probe = await this.probeUnwatched(repo, getHeadRemotes(last.result.summary.baseDependsOn), false, signal);
+				if (entry.disposed) return;
+				moved = await getMovedFields(repo, last, probe, true, signal);
+			}
+		} catch {}
+		if (entry.disposed) return;
+		if (moved == null) {
+			dropSeed(entry);
+			entry.pending |= 23;
+			return;
+		}
+		if (deferDirty) {
+			entry.pending |= moved.fields & -2;
+			entry.dirtyReadAt = last.dirtyReadAt;
+			entry.dirtyReadTimer = setTimeout(() => {
+				entry.dirtyReadTimer = void 0;
+				this.queue(entry, dirtyField);
+			}, maxDeferredDirtyMs);
+			if (entry.pending === 0 && entry.seed != null) {
+				const seed = entry.seed;
+				entry.error = void 0;
+				entry.seed = void 0;
+				entry.value = seed;
+				this.fireChange(entry, seed);
+			}
+		} else entry.pending |= moved.fields;
+		if (moved.baseMoves != null) {
+			entry.baseMoves ??= /* @__PURE__ */ new Set();
+			for (const ref of moved.baseMoves) entry.baseMoves.add(ref);
+		}
+	}
 	onRepoChanged(entry, e) {
-		const value = entry.value;
+		const value = entry.value ?? entry.seed;
 		if (value == null || e.changed("unknown", "head")) {
 			this.queue(entry, allFields | (e.changed("config") ? baseConfigField : 0));
 			return;
@@ -267,14 +529,28 @@ var WorktreeSummaryService = class {
 			if (entry.handle == null) continue;
 			const value = entry.value;
 			if (value != null && (value.branch == null || e.refs != null && !e.refs.has(value.branch))) continue;
-			const commonPath = this.getCommonPath?.(entry.key);
-			if (commonPath != null && commonPath !== e.repoPath) continue;
+			if (!this.isInRepository(entry.key, e.repoPath)) continue;
 			this.queue(entry, baseKeysField);
 		}
+		for (const read of this.unwatchedReads.values()) {
+			const value = read.result.summary;
+			if (value.branch == null || e.refs != null && !e.refs.has(value.branch)) continue;
+			if (!this.isInRepository(value.repoPath, e.repoPath)) continue;
+			read.due |= baseKeysField;
+		}
+		for (const flight of this.unwatchedFlights.values()) {
+			if (!this.isInRepository(flight.key, e.repoPath)) continue;
+			flight.due |= baseKeysField;
+		}
+	}
+	isInRepository(key, commonPath) {
+		const path = this.getCommonPath?.(key);
+		return path == null || path === commonPath;
 	}
 	queue(entry, fields, baseMoves) {
 		if (entry.disposed || fields === 0) return;
-		entry.pending |= entry.value == null || entry.value.stale ? fields | 23 : fields;
+		const value = entry.value ?? entry.seed;
+		entry.pending |= value == null || value.stale ? fields | 23 : fields;
 		if (baseMoves != null) {
 			entry.baseMoves ??= /* @__PURE__ */ new Set();
 			for (const ref of baseMoves) entry.baseMoves.add(ref);
@@ -336,7 +612,8 @@ var WorktreeSummaryService = class {
 		return true;
 	}
 	async run(entry, fields, baseMoves) {
-		const previous = entry.value;
+		const { value, seed } = entry;
+		const previous = value ?? seed;
 		let result;
 		try {
 			const repo = this.getRepository(entry.key);
@@ -350,16 +627,27 @@ var WorktreeSummaryService = class {
 		if (entry.disposed) return;
 		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.baseKeys = result.baseKeys;
 		entry.baseConfigKey = entry.pending & baseConfigField ? void 0 : result.baseConfigKey;
 		entry.baseDefaultBranch = result.baseDefaultBranch;
-		if (previous != null && summariesEqual(previous, result.summary)) return;
-		entry.value = result.summary;
-		this.fireChange(entry, result.summary);
+		const dirtyConfirmed = result.dirtyReadAt != null && entry.dirtyReadAt != null;
+		if (dirtyConfirmed) clearDeferredDirty(entry);
+		if (value != null && summariesEqual(value, result.summary)) {
+			if (dirtyConfirmed) this.fireChange(entry, value);
+			return;
+		}
+		const summary = value == null && seed != null && summariesEqual(seed, result.summary) ? seed : result.summary;
+		entry.value = summary;
+		this.fireChange(entry, summary);
 	}
 	fail(entry, ex) {
 		const previous = entry.value;
 		if (previous == null) {
+			if (entry.seed != null) {
+				dropSeed(entry);
+				if (entry.pending !== 0) entry.pending |= 23;
+			}
 			if (entry.error == null) _logger.warn(`WorktreeSummaryService: reading '${entry.key}' failed: ${String(ex)}`);
 			entry.error = ex instanceof Error ? ex : new Error(String(ex));
 			return;
@@ -394,6 +682,8 @@ var WorktreeSummaryService = class {
 		entry.handle?.dispose();
 		entry.handle = void 0;
 		entry.value = void 0;
+		entry.seed = void 0;
+		clearDeferredDirty(entry);
 		entry.baseKeys = void 0;
 		entry.baseConfigKey = void 0;
 		entry.baseDefaultBranch = void 0;
@@ -412,6 +702,19 @@ function* getConfigRelevantRefs(value) {
 	if (value.upstream != null) yield `refs/heads/${value.upstream.name}`;
 	yield* value.baseDependsOn;
 }
+/** Drops the saved read a first run was to start from, with the values its base read consulted and its dirty flag */
+function dropSeed(entry) {
+	entry.seed = void 0;
+	clearDeferredDirty(entry);
+	entry.baseKeys = void 0;
+	entry.baseConfigKey = void 0;
+	entry.baseDefaultBranch = void 0;
+}
+function clearDeferredDirty(entry) {
+	entry.dirtyReadAt = void 0;
+	clearTimeout(entry.dirtyReadTimer);
+	entry.dirtyReadTimer = void 0;
+}
 function createEntry(key) {
 	return {
 		key,
@@ -421,6 +724,9 @@ function createEntry(key) {
 		handle: void 0,
 		listeners: void 0,
 		value: void 0,
+		seed: void 0,
+		dirtyReadAt: void 0,
+		dirtyReadTimer: void 0,
 		baseKeys: void 0,
 		baseConfigKey: void 0,
 		baseDefaultBranch: void 0,
@@ -443,7 +749,12 @@ function createEntry(key) {
 */
 async function readSummary(repo, key, fields, previous, previousBaseKeys, previousBaseConfigKey, previousBaseDefaultBranch, baseMoves, signal, verifyBaseRemeasure) {
 	if (previous == null) fields |= allFields;
-	let dirtyRead = fields & dirtyField ? readDirty(repo, signal) : void 0;
+	let dirtyReadAt;
+	const startDirtyRead = () => {
+		dirtyReadAt = Date.now();
+		return readDirty(repo, signal);
+	};
+	let dirtyRead = fields & dirtyField ? startDirtyRead() : void 0;
 	let branch = previous?.branch;
 	let detached = previous?.detached ?? false;
 	let sha = previous?.sha;
@@ -460,7 +771,7 @@ async function readSummary(repo, key, fields, previous, previousBaseKeys, previo
 		behind = current?.upstream?.state.behind ?? 0;
 		if (previous != null && (branch !== previous.branch || detached !== previous.detached)) {
 			fields |= baseField;
-			dirtyRead ??= readDirty(repo, signal);
+			dirtyRead ??= startDirtyRead();
 		}
 	}
 	let base = previous?.base;
@@ -555,7 +866,123 @@ async function readSummary(repo, key, fields, previous, previousBaseKeys, previo
 		baseKeys,
 		baseConfigKey,
 		baseDefaultBranch,
-		baseError
+		baseError,
+		dirtyReadAt
+	};
+}
+async function getGitDir(repo) {
+	try {
+		return await repo.config.getGitDir?.();
+	} catch (ex) {
+		if (isCancellationError(ex)) throw ex;
+		return;
+	}
+}
+/** 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) {
+	let byName = tipsByNameCache.get(tips);
+	if (byName == null) {
+		const map = /* @__PURE__ */ new Map();
+		for (const tip of tips) map.set(tip.fullName, tip.sha);
+		byName = map;
+		tipsByNameCache.set(tips, byName);
+	}
+	return byName;
+}
+/**
+* The read groups due on a read from `last`, given what `probe` found of its inputs since (with the refs the base
+* depends on that moved): those `last` made due, and those whose inputs moved
+*/
+async function getMovedFields(repo, last, probe, probeDirty, signal) {
+	let fields = last.due;
+	let baseMoves;
+	const { inputs } = last;
+	const previous = last.result.summary;
+	if (probe.branch !== inputs.branch || probe.detached !== inputs.detached || probe.sha !== inputs.sha) fields |= allFields;
+	else {
+		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);
+		}
+		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);
+			if (configKey != null && configKey !== last.result.baseConfigKey) fields |= 18;
+		}
+	}
+	if (probeDirty || probe.index == null || probe.index !== inputs.index) fields |= dirtyField;
+	return {
+		fields,
+		baseMoves
+	};
+}
+/** 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;
+	return `${tips.get(`refs/remotes/${upstream}`) ?? ""}\0${tips.get(`refs/heads/${upstream}`) ?? ""}`;
+}
+/**
+* Reads where the `HEAD` symref of each of `remotes` (every remote's when `undefined`) points (`origin/main`) into
+* `heads`, as core's cached local reads answer it, skipping those already there: `undefined` when it has none (a
+* remote since removed included), `null` when the read failed
+*/
+async function readRemoteHeads(repo, heads, remotes, signal) {
+	if (remotes?.size === 0) return;
+	const names = remotes ?? (await repo.remotes.getRemotes(void 0, signal)).map((r) => r.name);
+	await Promise.all(Array.from(names, async (name) => {
+		if (heads.has(name)) return;
+		let target;
+		try {
+			target = await repo.branches.getDefaultBranchName(name, { local: true }, signal);
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+			target = null;
+		}
+		heads.set(name, target);
+	}));
+}
+/** The remote whose `HEAD` symref `ref` is; `undefined` for any other ref */
+function getHeadRemote(ref) {
+	if (!ref.startsWith("refs/remotes/") || !ref.endsWith("/HEAD")) return void 0;
+	return ref.slice(13, -5);
+}
+/** The remotes whose `HEAD` symref is among `refs` */
+function getHeadRemotes(refs) {
+	const remotes = /* @__PURE__ */ new Set();
+	for (const ref of refs) {
+		const remote = getHeadRemote(ref);
+		if (remote != null) remotes.add(remote);
+	}
+	return remotes;
+}
+/**
+* What `probe` found of `ref`, a ref the base depends on: for a remote's `HEAD` symref, which the ref tips leave out,
+* the ref it points at, since its tip follows that ref's, itself a dependency; else its tip. `null` for a symref of a
+* remote it didn't read: only when the read found HEAD elsewhere than the probe did and read the base for that, which
+* the next probe sees as HEAD moving anyway
+*/
+function getBaseInput(probe, ref) {
+	const remote = getHeadRemote(ref);
+	if (remote == null) return probe.tips.get(ref);
+	return probe.remoteHeads.has(remote) ? probe.remoteHeads.get(remote) : null;
+}
+/** 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,
+		index: probe.index
 	};
 }
 async function readBaseConfig(repo, signal) {