@gitkraken/core-gitlens 0.16.5 → 0.18.0

package/dist/git/watching/watchGroup.js

@@ -1,15 +1,28 @@
 import { some } from "../../utils/iterable.js";
-import { isDescendant, joinPaths, relative } from "../../utils/path.js";
+import { dirname, isAbsolute, isDescendant, joinPaths, normalizePath, relative } from "../../utils/path.js";
+import { FileType } from "../context.js";
 import { GitDirProbeTarget } from "./gitDirPoller.js";
-import { dotGitGlobCombined, dotGitGlobCommon, dotGitGlobRoot, getGitDirRefProbes, gitDirCommonProbes, gitDirExcludes, gitDirProbesByEmittedPath, gitDirRootProbes, shouldIgnoreRepoPath } from "./watcherPatterns.js";
+import { dotGitGlobCombined, dotGitGlobCommon, dotGitGlobRoot, getGitDirRefProbes, getIgnoredWorktreeFolderExcludes, gitDirCommonProbes, gitDirExcludes, gitDirProbesByEmittedPath, gitDirRootProbes, shouldIgnoreRepoPath } from "./watcherPatterns.js";
 import { allWatchedRepositoryChanges, classifyGitDirChange } from "./classifyChange.js";
 import { diffGitConfigSections, parseGitConfigBytes } from "./configSections.js";
 //#region ../git/src/watching/watchGroup.ts
 /**
-* How long a read of the shared `.git/config` may take before it counts as failed (unconfined). Reads run one at a
-* time, so one that never settles, as on a hung network or WSL mount, would otherwise hold back every later report.
+* How long a read of the shared `.git/config`, or of the worktrees' admin entries, may take before it counts as failed.
+* Reads of each run one at a time, so one that never settles, as on a hung network or WSL mount, would otherwise hold
+* back every later report.
 */
-const configReadTimeoutMs = 5e3;
+const readTimeoutMs = 5e3;
+/**
+* How many removed admin entries are remembered. Each watcher reports a removal once for each file it watched in the
+* entry, and two watchers see the common dir beside a main checkout, so its reports outlive any single one of them
+*/
+const removedWorktreeIdsLimit = 64;
+/**
+* How long after an admin entry's `gitdir` couldn't be read it is read once more. A watcher can report the entry before
+* git wrote its `gitdir`, and then miss the write itself (a new directory's files go unseen until it is watched)
+*/
+const worktreeRetryDelayMs = 250;
+function noop() {}
 /**
 * Manages filesystem watchers for a single physical `.git` directory,
 * shared across all worktrees that reference it.
@@ -30,12 +43,42 @@ const configReadTimeoutMs = 5e3;
 * starts, is the baseline and delivers nothing; a report arriving before it completes may describe a change it
 * already holds, so it is delivered unconfined. A read that fails or doesn't settle within a few seconds, or a file
 * git couldn't parse, is unconfined too.
+*
+* Given a `readFile`, a `readDirectory` (a directory's entries with their types, only the directories counting as
+* admin entries) and the folders whose worktrees the host has core ignore (a tool's throwaway worktrees, which no
+* host shows), the group reports no change of an ignored worktree's admin entry
+* (`<common>/worktrees/<id>`) to any session. Only registered folders count, since a user may keep real worktrees
+* anywhere, `.git` included. It lists the entries and reads each one's `gitdir` once as it starts, and again after a
+* watcher dropped events; a report arriving meanwhile is told at once, and decided once the listing settles, so what
+* is known of its entry catches up. From then on it reads an entry only when its `gitdir` may be new (the entry was
+* created, or its `gitdir` written, or it was removed before), so a real worktree's HEAD moves are told at once,
+* unread. Of two reads of one entry, the later decides both reports. An entry it doesn't know whose `gitdir` can't be
+* read (a watcher can report one before git writes it, and miss the write) is read once more a moment later, its
+* reports held until then, and told if it still can't be. Only the entry's directory or its `gitdir` going is a
+* removal; a deleted `HEAD` (a watcher may report git's lock file renamed over it as a delete) or `locked` is told as
+* the entry is known. Removing an entry deletes the `gitdir` a read needs, so a removal is told from what the entry was
+* known to be (before a read that couldn't read it, if one is waiting to read it again), and an entry it never knew is
+* told as real. Any other report of a removed entry but a delete is read, and one that can't be read is the removal's
+* own (a watcher may report the entry's directory changed beside each file it deletes), unless it creates the entry
+* again. A report of the `worktrees` directory itself (a coalesced
+* removal, a parent directory change, a poll, which sees nothing finer) lists it again: it is told to every session
+* when a real entry was added or removed since the last listing, and to none when only ignored ones were. Git removes
+* the directory with its last entry, so a directory that isn't there is an empty listing, as is a removal of it that
+* can't be listed. Since a listing (or a worktree moved into or out of a folder) changes what every session shows, it
+* is told to all of them; the other watcher's report of the same change then finds nothing left to tell. Where only a
+* poll watches the common dir, it sees just the `worktrees` directory, so an entry removed and added again under the
+* same id between two polls, or an entry's HEAD or lock changed in place, goes untold.
+*
+* Given the folders, the watchers over the common dir leave each one unwatched, since a tool's checkout there would
+* otherwise have every directory of it watched; one that shares a top-level directory with what the `.git` watch reads
+* stays watched.
 */
 var WatchGroup = class {
 	commonGitDir;
 	provider;
 	poller;
 	readFile;
+	readDirectory;
 	_sessions = /* @__PURE__ */ new Map();
 	_commonWatcher;
 	_commonReliability = "reliable";
@@ -47,12 +90,50 @@ var WatchGroup = class {
 	_configBaselining = false;
 	_configReading = false;
 	_configRereadQueued = false;
-	constructor(commonGitDir, provider, poller, readFile) {
+	/**
+	* Settles once the latest baseline of the admin entries was taken; `undefined` when the group can't tell an
+	* ignored worktree's, so every report is told at once
+	*/
+	_worktreesBaseline;
+	/** A baseline is pending, so a report waits for it */
+	_worktreesBaselining = false;
+	_worktreesRebaselineQueued = false;
+	/** Set by the first baseline; while empty, nothing is ignored and every report is told at once */
+	_ignoredWorktreeRoots = [];
+	/** Listings run one at a time, so each compares with the one before it */
+	_worktreesQueue = Promise.resolve();
+	/** The `worktrees` directory's reports waiting on the queued listing; `undefined` while none is queued */
+	_worktreesRescanQueued;
+	/** The admin entries the last listing found */
+	_listedWorktreeIds = /* @__PURE__ */ new Set();
+	/** Admin entries known to exist, by id: whether each is an ignored worktree's */
+	_worktreeIds = /* @__PURE__ */ new Map();
+	/** What removed admin entries were, by id, oldest first */
+	_removedWorktreeIds = /* @__PURE__ */ new Map();
+	/**
+	* Each id's latest `gitdir` read, settling with what it found and what the id was known to be before it; only it
+	* may update what is known of the id. A removal of the entry drops it
+	*/
+	_worktreeReads = /* @__PURE__ */ new Map();
+	/** Admin entries whose `gitdir` couldn't be read, by id, waiting to be read once more */
+	_worktreeRetries = /* @__PURE__ */ new Map();
+	/** The `.git` excludes of a watcher over the common git dir, with the ignored worktrees' folders it may leave out */
+	_commonGitDirExcludes;
+	constructor(commonGitDir, provider, poller, readFile, readDirectory, ignoredWorktreeRoots, ignoredWorktreeFolders) {
 		this.commonGitDir = commonGitDir;
 		this.provider = provider;
 		this.poller = poller;
 		this.readFile = readFile;
+		this.readDirectory = readDirectory;
+		const folders = getIgnoredWorktreeFolderExcludes(ignoredWorktreeFolders);
+		this._commonGitDirExcludes = folders.length ? [...gitDirExcludes, ...folders] : gitDirExcludes;
 		if (readFile != null) this.readConfigBaseline();
+		if (readFile != null && readDirectory != null && ignoredWorktreeRoots != null) this.queueWorktreesBaseline(async () => {
+			const roots = await this.withTimeout(() => Promise.resolve(ignoredWorktreeRoots));
+			if (this._disposed || !Array.isArray(roots) || !roots.length) return;
+			this._ignoredWorktreeRoots = roots;
+			await this.listWorktrees("baseline");
+		});
 	}
 	[Symbol.dispose]() {
 		this.dispose();
@@ -67,6 +148,11 @@ var WatchGroup = class {
 		}
 		this._sessions.clear();
 		this.disposeCommonWatcher();
+		for (const retry of this._worktreeRetries.values()) {
+			clearTimeout(retry.timer);
+			retry.resolve(void 0);
+		}
+		this._worktreeRetries.clear();
 	}
 	get sessions() {
 		return this._sessions;
@@ -91,7 +177,7 @@ var WatchGroup = class {
 				if (event.reason !== "overflow") e.target?.forget(event.path);
 				this.onRootEvent(event, e);
 			}
-		}, this.getWatcherOptions((state) => {
+		}, this.getWatcherOptions(gitDir.uri.fsPath, (state) => {
 			if (entry == null) initialReliability = state;
 			else if (this._sessions.get(repoPath) === entry) this.setRootReliability(entry, state);
 		}));
@@ -129,7 +215,7 @@ var WatchGroup = class {
 		if (this._commonWatcher != null || this._disposed) return;
 		let watcher;
 		let initialReliability = "reliable";
-		const options = this.getWatcherOptions((state) => {
+		const options = this.getWatcherOptions(this.commonGitDir, (state) => {
 			if (watcher == null) initialReliability = state;
 			else if (this._commonWatcher === watcher) this.setCommonReliability(state);
 		});
@@ -150,11 +236,21 @@ var WatchGroup = class {
 		}
 	}
 	/** Hosts that didn't opt into polling get exactly the options they always had */
-	getWatcherOptions(onDidChangeReliability) {
+	getWatcherOptions(basePath, onDidChangeReliability) {
+		const excludes = this.getExcludes(basePath);
 		return this.poller != null ? {
-			excludes: gitDirExcludes,
+			excludes,
 			onDidChangeReliability
-		} : { excludes: gitDirExcludes };
+		} : { excludes };
+	}
+	/**
+	* The ignored worktrees' folders join the `.git` excludes of a watcher over the common git dir: a tool that keeps its
+	* throwaway checkouts inside the git dir would otherwise have each one's every directory watched, and every file it
+	* writes reported. Every other watcher sits on a linked worktree's admin entry, which holds none of them
+	*/
+	getExcludes(basePath) {
+		if (this._commonGitDirExcludes === gitDirExcludes) return gitDirExcludes;
+		return normalizePath(basePath) === normalizePath(this.commonGitDir) ? this._commonGitDirExcludes : gitDirExcludes;
 	}
 	setRootReliability(entry, state, initial) {
 		const previous = entry.reliability;
@@ -171,7 +267,10 @@ var WatchGroup = class {
 			this.poller.add(target);
 		}
 		if (state === "unwatchable" === (previous === "unwatchable")) return;
-		if (!initial) this.deliverOverflow(entry);
+		if (!initial) {
+			this.deliverOverflow(entry);
+			if (entry.coversCommon) this.rebaselineWorktrees();
+		}
 		entry.hooks.onUnwatchableChanged?.(entry.repoPath);
 	}
 	setCommonReliability(state, initial) {
@@ -196,6 +295,7 @@ var WatchGroup = class {
 			if (!initial) this.deliverOverflow(entry);
 			entry.hooks.onUnwatchableChanged?.(entry.repoPath);
 		}
+		if (!initial) this.rebaselineWorktrees();
 	}
 	stopPolling(entry) {
 		if (entry.target == null) return;
@@ -242,6 +342,7 @@ var WatchGroup = class {
 				if (entry.coversCommon) continue;
 				this.deliverOverflow(entry);
 			}
+			this.rebaselineWorktrees();
 			return;
 		}
 		if (!isDescendant(event.path, this.commonGitDir)) return;
@@ -253,7 +354,7 @@ var WatchGroup = class {
 		}
 		const isFetchHead = relativePath === "FETCH_HEAD";
 		const isExclude = relativePath === "info/exclude";
-		const changes = isFetchHead ? void 0 : classifyGitDirChange(relativePath);
+		const changes = isFetchHead ? void 0 : withWorktreeEntryHead(classifyGitDirChange(relativePath), relativePath, event.reason);
 		if (changes == null && !isFetchHead && !isExclude) return;
 		const ref = changes != null ? getChangedRef(relativePath) : void 0;
 		let ownerId;
@@ -261,6 +362,16 @@ var WatchGroup = class {
 			const idEnd = relativePath.indexOf("/", 10);
 			if (idEnd !== -1 && relativePath.substring(idEnd + 1) === "HEAD") ownerId = relativePath.substring(10, idEnd);
 		}
+		if (changes != null && this.isWorktreesReport(changes)) {
+			const sessions = [...this._sessions.values()].filter((e) => !e.coversCommon && (ownerId == null || e.worktreeId !== ownerId));
+			this.onWorktreesReported(relativePath, event.reason, () => {
+				for (const entry of sessions) {
+					if (this._disposed || this._sessions.get(entry.repoPath) !== entry) continue;
+					entry.hooks.onRepoChanged(entry.repoPath, changes, ref);
+				}
+			});
+			return;
+		}
 		for (const entry of this._sessions.values()) {
 			if (entry.coversCommon) continue;
 			if (isFetchHead) {
@@ -279,6 +390,7 @@ var WatchGroup = class {
 	onRootEvent(event, entry) {
 		if (event.reason === "overflow") {
 			this.deliverOverflow(entry);
+			if (entry.coversCommon) this.rebaselineWorktrees();
 			return;
 		}
 		if (!isDescendant(event.path, entry.gitDirPath)) return;
@@ -292,10 +404,273 @@ var WatchGroup = class {
 			this.onConfigReported();
 			return;
 		}
-		const changes = classifyGitDirChange(relativePath);
-		if (changes != null) entry.hooks.onRepoChanged(entry.repoPath, changes, getChangedRef(relativePath));
+		const changes = withWorktreeEntryHead(classifyGitDirChange(relativePath), relativePath, event.reason);
+		if (changes != null && entry.coversCommon && this.isWorktreesReport(changes)) this.onWorktreesReported(relativePath, event.reason, () => {
+			if (this._disposed || this._sessions.get(entry.repoPath) !== entry) return;
+			entry.hooks.onRepoChanged(entry.repoPath, changes, getChangedRef(relativePath));
+		});
+		else if (changes != null) entry.hooks.onRepoChanged(entry.repoPath, changes, getChangedRef(relativePath));
 		if (relativePath === "info/exclude") entry.hooks.onIgnoresChanged?.(entry.repoPath);
 	}
+	/** A report of the `worktrees` directory, an admin entry or a file in it, once the group may tell them apart */
+	isWorktreesReport(changes) {
+		return this._worktreesBaseline != null && changes.includes("worktrees") && changes.every((c) => c === "worktrees" || c === "worktreeHead");
+	}
+	/** `deliver` tells the sessions the report reaches of it, should the report concern them (see above) */
+	onWorktreesReported(relativePath, reason, deliver) {
+		if (this._worktreesBaselining && this._worktreesBaseline != null) {
+			deliver();
+			this._worktreesBaseline.then(() => this.decideWorktreesReport(relativePath, reason, noop));
+			return;
+		}
+		this.decideWorktreesReport(relativePath, reason, deliver);
+	}
+	decideWorktreesReport(relativePath, reason, deliver) {
+		if (this._disposed) return;
+		if (!this._ignoredWorktreeRoots.length) {
+			deliver();
+			return;
+		}
+		if (relativePath === "worktrees") {
+			this.queueWorktreesRescan(reason, deliver);
+			return;
+		}
+		const idEnd = relativePath.indexOf("/", 10);
+		const id = idEnd === -1 ? relativePath.substring(10) : relativePath.substring(10, idEnd);
+		const file = idEnd === -1 ? void 0 : relativePath.substring(idEnd + 1);
+		if (reason === "delete" && (file == null || file === "gitdir")) {
+			if (this.forgetWorktreeId(id) !== true) deliver();
+			return;
+		}
+		const removed = this._worktreeIds.has(id) ? void 0 : this._removedWorktreeIds.get(id);
+		const known = this._worktreeIds.get(id) ?? (reason === "delete" ? removed : void 0);
+		if (known != null && file !== "gitdir" && !(file == null && reason === "create")) {
+			if (!known) deliver();
+			return;
+		}
+		const retry = removed == null || reason === "create";
+		this.readWorktreeId(id, retry).then(([ignored, previous]) => {
+			if (this._disposed) return;
+			if (ignored == null) {
+				if (retry) this.waitForWorktreeRetry(id, deliver);
+				else if (removed === false) deliver();
+				return;
+			}
+			if (previous != null && ignored !== previous) {
+				this.deliverWorktreesChange();
+				return;
+			}
+			if (!ignored) deliver();
+		});
+	}
+	/**
+	* Reads the entry's `gitdir`: whether it names an ignored worktree (`undefined` when it can't be read), and what the
+	* id was known to be when this read replaced it. Reads of one id can settle out of order (a slow one from before the
+	* worktree moved out of the folder), so only the latest updates what is known of it; an earlier one settles with
+	* what the latest finds, without what the id was, since the latest tells a move itself, or once the entry was removed
+	* since, with what the removal found it was. One that can't read the entry forgets what it was known to be, since git
+	* may be writing its `gitdir` again, and reads it once more a moment later, unless `retry` is false (it then leaves
+	* what is known as it was); one that can settles that read, if pending.
+	*/
+	readWorktreeId(id, retry = true) {
+		const read = this.readIgnoredWorktree(id).then((ignored) => {
+			const latest = this._worktreeReads.get(id);
+			if (latest !== read) {
+				if (latest == null) return [this._removedWorktreeIds.get(id), void 0];
+				return latest.then(([found]) => {
+					if (found == null && retry && this._worktreeReads.has(id)) this.scheduleWorktreeRetry(id, void 0);
+					return [found, void 0];
+				});
+			}
+			const previous = this._worktreeIds.get(id);
+			if (ignored == null) {
+				if (!retry) return [void 0, previous];
+				this._removedWorktreeIds.delete(id);
+				this._worktreeIds.delete(id);
+				this.scheduleWorktreeRetry(id, previous);
+				return [void 0, previous];
+			}
+			this._removedWorktreeIds.delete(id);
+			this._worktreeIds.set(id, ignored);
+			this.settleWorktreeRetry(id, ignored);
+			return [ignored, previous];
+		});
+		this._worktreeReads.set(id, read);
+		return read;
+	}
+	/** Reads the entry once more a moment later, unless that is already pending; `previous` is what it was known to be */
+	scheduleWorktreeRetry(id, previous) {
+		if (this._disposed) return;
+		const pending = this._worktreeRetries.get(id);
+		if (pending != null) {
+			pending.previous ??= previous;
+			return;
+		}
+		let resolve;
+		const decided = new Promise((r) => {
+			resolve = r;
+		});
+		const timer = setTimeout(() => {
+			this.readWorktreeId(id).then(([ignored]) => {
+				if (this._worktreeRetries.get(id)?.decided === decided) this.settleWorktreeRetry(id, ignored);
+			});
+		}, worktreeRetryDelayMs);
+		this._worktreeRetries.set(id, {
+			timer,
+			delivers: [],
+			previous,
+			decided,
+			resolve
+		});
+	}
+	/**
+	* A report whose read couldn't read the entry waits on the entry's next read, and `deliver` is told then, unless that
+	* read finds an ignored worktree's; one still unreadable is told. Both watchers report each change of an entry, so
+	* the reports of one id wait on one read. Resolves with what it found, as {@link settleWorktreeRetry} does
+	*/
+	waitForWorktreeRetry(id, deliver) {
+		const known = this._worktreeIds.get(id);
+		if (known != null) {
+			if (!known) deliver?.();
+			return Promise.resolve(known);
+		}
+		const retry = this._worktreeRetries.get(id);
+		if (retry == null) return Promise.resolve(void 0);
+		if (deliver != null) retry.delivers.push(deliver);
+		return retry.decided;
+	}
+	/**
+	* Tells the reports waiting on the id's retry what the entry turned out to be: nothing when an ignored worktree's,
+	* every session when it moved into or out of an ignored folder, and the reports' own sessions otherwise, `ignored`
+	* being `undefined` when it still couldn't be read
+	*/
+	settleWorktreeRetry(id, ignored) {
+		const pending = this._worktreeRetries.get(id);
+		if (pending == null) return;
+		this._worktreeRetries.delete(id);
+		clearTimeout(pending.timer);
+		pending.resolve(ignored);
+		if (ignored != null && pending.previous != null && ignored !== pending.previous) this.deliverWorktreesChange();
+		else if (ignored !== true) for (const deliver of pending.delivers) deliver();
+	}
+	/**
+	* Takes `id` as removed, remembering what it was for the removal's other reports; returns that, or `undefined` when
+	* the id was never known
+	*/
+	forgetWorktreeId(id) {
+		this._worktreeReads.delete(id);
+		let ignored = this._worktreeIds.get(id);
+		const retry = this._worktreeRetries.get(id);
+		if (retry != null) {
+			this._worktreeRetries.delete(id);
+			clearTimeout(retry.timer);
+			retry.resolve(void 0);
+			ignored ??= retry.previous;
+		}
+		if (ignored == null) return this._removedWorktreeIds.get(id);
+		this._worktreeIds.delete(id);
+		this._removedWorktreeIds.delete(id);
+		this._removedWorktreeIds.set(id, ignored);
+		if (this._removedWorktreeIds.size > removedWorktreeIdsLimit) {
+			const [oldest] = this._removedWorktreeIds.keys();
+			this._removedWorktreeIds.delete(oldest);
+		}
+		return ignored;
+	}
+	/** Whether the entry's `gitdir` names an ignored worktree, or `undefined` when it can't be read. Never rejects */
+	async readIgnoredWorktree(id) {
+		const adminDir = joinPaths(this.commonGitDir, "worktrees", id);
+		const content = await this.readWithTimeout(joinPaths(adminDir, "gitdir"));
+		const dotGit = content != null ? new TextDecoder().decode(content).trim() : "";
+		const dotGitPath = dotGit ? normalizePath(isAbsolute(dotGit) ? dotGit : joinPaths(adminDir, dotGit)) : "";
+		if (!dotGitPath.endsWith("/.git")) return void 0;
+		const worktreePath = dirname(dotGitPath);
+		return this._ignoredWorktreeRoots.some((root) => isDescendant(worktreePath, root));
+	}
+	queueWorktreesBaseline(take) {
+		this._worktreesBaselining = true;
+		const baseline = this._worktreesQueue.then(take).catch(() => {}).finally(() => {
+			if (this._worktreesBaseline === baseline) this._worktreesBaselining = false;
+		});
+		this._worktreesBaseline = baseline;
+		this._worktreesQueue = baseline;
+	}
+	/** A watcher of the `worktrees` directory dropped events: whatever changed meanwhile went unseen */
+	rebaselineWorktrees() {
+		if (this._worktreesBaseline == null || this._worktreesRebaselineQueued || this._disposed) return;
+		if (!this._worktreesBaselining && !this._ignoredWorktreeRoots.length) return;
+		this._worktreesRebaselineQueued = true;
+		this.queueWorktreesBaseline(async () => {
+			this._worktreesRebaselineQueued = false;
+			if (this._disposed || !this._ignoredWorktreeRoots.length) return;
+			await this.listWorktrees("rebaseline");
+		});
+	}
+	/** The watchers' reports of the directory pile onto one queued listing, which tells them apart */
+	queueWorktreesRescan(reason, deliver) {
+		const queued = this._worktreesRescanQueued;
+		if (queued != null) {
+			queued.delivers.push(deliver);
+			queued.removal ||= reason === "delete";
+			return;
+		}
+		const rescan = {
+			delivers: [deliver],
+			removal: reason === "delete"
+		};
+		this._worktreesRescanQueued = rescan;
+		this._worktreesQueue = this._worktreesQueue.then(() => {
+			this._worktreesRescanQueued = void 0;
+			return this.listWorktrees("rescan", rescan.delivers, rescan.removal);
+		}).catch(() => {});
+	}
+	/**
+	* Lists the admin entries and compares them with the last listing. A baseline (or a rebaseline, after a watcher
+	* dropped events) reads every entry; a rescan only those it doesn't know, reading one it can't read once more a
+	* moment later. Git removes the directory with its last entry, so a directory that isn't there is an empty listing,
+	* whatever the reports said of it (a poll sees its removal as a change). A listing that fails otherwise is a
+	* baseline's empty directory, and a rescan's too when one of its reports (`delivers`) removed the directory. For any
+	* other rescan, it is a change it can't rule out, told to the reports' own sessions
+	*/
+	async listWorktrees(mode, delivers, removal) {
+		const readDirectory = this.readDirectory;
+		if (readDirectory == null) return;
+		const entries = await this.withTimeout(() => readDirectory(joinPaths(this.commonGitDir, "worktrees")).catch((ex) => {
+			if (isNotFound(ex)) return [];
+			throw ex;
+		}));
+		if (this._disposed) return;
+		const names = entries?.filter(([, type]) => type & FileType.Directory).map(([name]) => name);
+		if (names == null && mode === "rescan" && !removal) {
+			for (const deliver of delivers ?? []) deliver();
+			return;
+		}
+		const listing = new Set(names);
+		const previous = this._listedWorktreeIds;
+		this._listedWorktreeIds = listing;
+		let changed = false;
+		if (mode !== "baseline") for (const id of /* @__PURE__ */ new Set([...previous, ...this._worktreeIds.keys()])) {
+			if (listing.has(id)) continue;
+			if (this.forgetWorktreeId(id) !== true) changed = true;
+		}
+		const reads = await Promise.all([...listing].filter((id) => mode !== "rescan" || !previous.has(id) && !this._worktreeIds.has(id)).map(async (id) => {
+			const [ignored, known] = await this.readWorktreeId(id);
+			if (ignored != null || mode !== "rescan" || this._disposed) return [id, [ignored, known]];
+			return [id, [await this.waitForWorktreeRetry(id), void 0]];
+		}));
+		if (this._disposed || mode === "baseline") return;
+		const read = new Map(reads);
+		for (const id of listing) {
+			const result = read.get(id);
+			if (!previous.has(id)) {
+				if ((result != null ? result[0] : this._worktreeIds.get(id)) !== true) changed = true;
+			} else if (result?.[0] != null && result[1] != null && result[0] !== result[1]) changed = true;
+		}
+		if (changed) this.deliverWorktreesChange();
+	}
+	deliverWorktreesChange() {
+		for (const entry of this._sessions.values()) entry.hooks.onRepoChanged(entry.repoPath, ["worktrees", "worktreeHead"], void 0);
+	}
 	onConfigReported() {
 		if (this._configBaselining) {
 			this.deliverConfigChange(void 0);
@@ -343,14 +718,26 @@ var WatchGroup = class {
 	}
 	/** `undefined` when the file couldn't be read or parsed, or the read didn't settle in time */
 	async readConfig() {
+		const data = await this.readWithTimeout(joinPaths(this.commonGitDir, "config"));
+		try {
+			return data != null ? parseGitConfigBytes(data) : void 0;
+		} catch {
+			return;
+		}
+	}
+	/** `undefined` when the file couldn't be read, or the read didn't settle in time */
+	readWithTimeout(path) {
 		const readFile = this.readFile;
-		if (readFile == null) return void 0;
+		if (readFile == null) return Promise.resolve(void 0);
+		return this.withTimeout(() => readFile(path));
+	}
+	/** `undefined` when `read` rejects, or doesn't settle in time */
+	async withTimeout(read) {
 		let timer;
 		try {
-			const data = await Promise.race([readFile(joinPaths(this.commonGitDir, "config")), new Promise((resolve) => {
-				timer = setTimeout(resolve, configReadTimeoutMs, void 0);
+			return await Promise.race([read(), new Promise((resolve) => {
+				timer = setTimeout(resolve, readTimeoutMs, void 0);
 			})]);
-			return data != null ? parseGitConfigBytes(data) : void 0;
 		} catch {
 			return;
 		} finally {
@@ -366,6 +753,24 @@ var WatchGroup = class {
 		else entry.hooks.onRepoChanged(entry.repoPath, ["config", "remotes"], false);
 	}
 };
+/**
+* `changes` with `worktreeHead` for a report that can stand for an entry's HEAD created or deleted with it: the
+* `worktrees` directory, an entry created or deleted, or its `gitdir` deleted. A watcher may coalesce the subtree a
+* removal deletes into one report of its parent, so no report of the HEAD comes. An entry's directory merely changed
+* stays `worktrees` alone: a watcher may report it beside each file in it, a lock's `locked` included
+*/
+function withWorktreeEntryHead(changes, relativePath, reason) {
+	if (changes?.length !== 1 || changes[0] !== "worktrees") return changes;
+	if (relativePath === "worktrees") return ["worktrees", "worktreeHead"];
+	const idEnd = relativePath.indexOf("/", 10);
+	if (idEnd === -1) return reason === "create" || reason === "delete" ? ["worktrees", "worktreeHead"] : changes;
+	return reason === "delete" && relativePath.substring(idEnd + 1) === "gitdir" ? ["worktrees", "worktreeHead"] : changes;
+}
+/** The path doesn't exist: Node's error, or the one VS Code's file system raises */
+function isNotFound(ex) {
+	const code = ex?.code;
+	return code === "ENOENT" || code === "FileNotFound";
+}
 /** The shared `.git/config` (or the lock git writes it through), relative to the common git dir */
 function isConfigFile(relativePath) {
 	return relativePath === "config" || relativePath === "config.lock";