@gitkraken/core-gitlens 0.10.7 → 0.11.0

package/dist/git/watching/gitIgnoreFilter.js

@@ -1,33 +1,57 @@
 import { getScopedCounter } from "../../utils/counter.js";
+import { getSettledValue } from "../../utils/promise.js";
+import { isLinux } from "../../utils/platform.js";
 import { fileUri } from "../../utils/uri.js";
 import ignore from "ignore";
 //#region ../git/src/watching/gitIgnoreFilter.ts
 /**
+* Case sensitivity when `core.ignorecase` is unset or unreadable. `ignore` matches case-insensitively by default, but
+* git follows `core.ignorecase` — false on Linux (and on a case-sensitive macOS volume), where matching `Build/`
+* against `build/` would call a real change ignored and drop it.
+*/
+const defaultIgnoreCase = !isLinux;
+/**
 * In-memory gitignore filter using the `ignore` npm package.
 * Fully library-owned — no VS Code dependencies.
 *
-* Loads patterns eagerly on creation from:
-* 1. `<repoPath>/.gitignore`
-* 2. `<gitDirPath>/info/exclude`
-* 3. Global excludes file (`core.excludesFile`)
+* Loads patterns eagerly on creation, in git's precedence order (lowest first):
+* 1. Global excludes file (`core.excludesFile`)
+* 2. `info/exclude`
+* 3. `<repoPath>/.gitignore`
+* 4. Nested `.gitignore` files (via `getGitIgnorePaths`), deeper overriding shallower
 *
 * Once loaded, all checks are **synchronous** for maximum performance.
 * Call `ready()` before first use to ensure patterns are loaded.
 */
 var GitIgnoreFilter = class {
-	ig = ignore();
+	ig = ignore({ ignorecase: defaultIgnoreCase });
+	/** Matchers for nested `.gitignore` files, keyed by their repo-relative directory (no trailing slash) */
+	nested;
+	/** The newest load, which {@link ready} waits for; cleared once it settles */
 	loading;
+	/** The load running now; at most one runs at a time */
+	inflight;
+	/** The one load queued behind {@link inflight}, which every refresh made meanwhile shares */
+	trailing;
 	_generation = getScopedCounter();
+	_scratchMatchers = [];
+	_scratchBases = [];
 	repoPath;
 	gitDirPath;
 	fs;
 	getGlobalExcludesPath;
+	getInfoExcludePath;
+	getGitIgnorePaths;
+	getIgnoreCase;
 	constructor(options) {
 		this.repoPath = options.repoPath;
 		this.gitDirPath = options.gitDirPath;
 		this.fs = options.fs;
 		this.getGlobalExcludesPath = options.getGlobalExcludesPath;
-		this.loading = this.loadPatterns();
+		this.getInfoExcludePath = options.getInfoExcludePath;
+		this.getGitIgnorePaths = options.getGitIgnorePaths;
+		this.getIgnoreCase = options.getIgnoreCase;
+		this.startLoad();
 	}
 	/** Resolves when patterns are loaded. Safe to call multiple times. */
 	async ready() {
@@ -35,13 +59,15 @@ var GitIgnoreFilter = class {
 	}
 	/**
 	* Check if a path is ignored. Must be called after `ready()`.
-	* @param relativePath Path relative to the repository root (forward slashes)
+	* Errs toward "not ignored": a false "ignored" drops a real change, a false "not ignored" only costs a refresh.
+	* @param relativePath Path relative to the repository root (forward slashes; a trailing slash marks a directory)
 	* @returns true if the path should be ignored
 	*/
 	isIgnored(relativePath) {
 		if (!relativePath) return false;
 		try {
-			return this.ig.ignores(relativePath);
+			if (this.nested == null) return this.ig.ignores(relativePath);
+			return this.isIgnoredNested(relativePath, this.nested);
 		} catch {
 			return false;
 		}
@@ -51,41 +77,172 @@ var GitIgnoreFilter = class {
 	* Must be called after `ready()`.
 	*/
 	filter(relativePaths) {
-		return this.ig.filter(relativePaths);
+		return relativePaths.filter((p) => !this.isIgnored(p));
+	}
+	/**
+	* Reload all patterns (e.g., after a .gitignore or info/exclude changes), rediscovering nested `.gitignore` files.
+	* Returns a promise that resolves when a reload started after this call is complete.
+	*
+	* Single-flight: an idle filter reloads at once, but while a reload runs, every further call shares one reload
+	* queued behind it — a checkout touching many `.gitignore` files costs two reloads, not one per file.
+	*/
+	refresh() {
+		if (this.inflight == null) return this.startLoad();
+		if (this.trailing == null) {
+			const run = () => {
+				this.trailing = void 0;
+				return this.startLoad();
+			};
+			this.trailing = this.inflight.then(run, run);
+		}
+		this.loading = this.trailing;
+		return this.trailing;
+	}
+	startLoad() {
+		const load = this.loadPatterns().finally(() => {
+			if (this.inflight === load) this.inflight = void 0;
+			if (this.loading === load) this.loading = void 0;
+		});
+		this.inflight = load;
+		this.loading = load;
+		return load;
 	}
 	/**
-	* Reload all patterns (e.g., after .gitignore or info/exclude changes).
-	* Returns a promise that resolves when reload is complete.
+	* Mirrors git's directory walk: each ancestor directory is checked shallow→deep, and the first one found ignored
+	* ignores the whole path (git never descends into it, so nothing below can re-include it). At each level, the
+	* matchers whose directory is a proper ancestor apply, and the deepest decisive one wins, falling back to the root.
 	*/
-	async refresh() {
-		this.loading = this.loadPatterns();
-		await this.loading;
+	isIgnoredNested(path, nested) {
+		const matchers = this._scratchMatchers;
+		const bases = this._scratchBases;
+		try {
+			const last = path.length - 1;
+			let slash = path.indexOf("/");
+			while (slash !== -1 && slash < last) {
+				if (this.isLevelIgnored(path, slash + 1, matchers, bases)) return true;
+				const matcher = nested.get(path.slice(0, slash));
+				if (matcher != null) {
+					matchers.push(matcher);
+					bases.push(slash + 1);
+				}
+				slash = path.indexOf("/", slash + 1);
+			}
+			return this.isLevelIgnored(path, path.length, matchers, bases);
+		} finally {
+			matchers.length = 0;
+			bases.length = 0;
+		}
+	}
+	/** Whether `path.slice(0, end)` is ignored, given its ancestors aren't */
+	isLevelIgnored(path, end, matchers, bases) {
+		for (let i = matchers.length - 1; i >= 0; i--) {
+			const verdict = this.testLevel(matchers[i], path.slice(bases[i], end));
+			if (verdict != null) return verdict;
+		}
+		return this.testLevel(this.ig, path.slice(0, end)) ?? false;
+	}
+	/** Returns the matcher's decisive verdict for `path`, or undefined when it has none */
+	testLevel(matcher, path) {
+		const result = matcher.test(path);
+		if (result.unignored) return false;
+		if (!result.ignored) return void 0;
+		const parentEnd = path.lastIndexOf("/", path.length - 2);
+		if (parentEnd !== -1 && matcher.test(path.slice(0, parentEnd + 1)).ignored) return false;
+		return true;
 	}
 	async loadPatterns() {
 		const id = this._generation.next();
-		const newIg = ignore();
-		await Promise.allSettled([
-			this.loadFile(newIg, `${this.repoPath}/.gitignore`),
-			this.loadFile(newIg, `${this.gitDirPath}/info/exclude`),
-			this.loadGlobalExcludes(newIg)
+		const [globalResult, infoResult, rootResult, nestedResult, ignoreCaseResult] = await Promise.allSettled([
+			this.readGlobalExcludes(),
+			this.readInfoExclude(),
+			this.readFile(`${this.repoPath}/.gitignore`),
+			this.loadNested(),
+			this.readIgnoreCase()
 		]);
 		if (id !== this._generation.current) return;
-		this.ig = newIg;
-		this.loading = void 0;
+		const options = { ignorecase: getSettledValue(ignoreCaseResult) ?? defaultIgnoreCase };
+		const ig = ignore(options);
+		for (const content of [
+			getSettledValue(globalResult),
+			getSettledValue(infoResult),
+			getSettledValue(rootResult)
+		]) {
+			if (!content) continue;
+			try {
+				ig.add(content);
+			} catch {}
+		}
+		let nested;
+		const nestedContents = getSettledValue(nestedResult);
+		if (nestedContents?.size) {
+			nested = /* @__PURE__ */ new Map();
+			for (const [dir, content] of nestedContents) try {
+				nested.set(dir, ignore(options).add(content));
+			} catch {}
+		}
+		this.ig = ig;
+		this.nested = nested?.size ? nested : void 0;
+	}
+	/** Reads every nested `.gitignore`, keyed by its repo-relative directory (no trailing slash) */
+	async loadNested() {
+		if (this.getGitIgnorePaths == null) return void 0;
+		let paths;
+		try {
+			paths = await this.getGitIgnorePaths();
+		} catch {
+			return;
+		}
+		const suffix = "/.gitignore";
+		const dirs = /* @__PURE__ */ new Set();
+		for (const path of paths) {
+			if (path.length <= 11 || !path.endsWith(suffix)) continue;
+			dirs.add(path.slice(0, -11));
+		}
+		if (!dirs.size) return void 0;
+		const entries = await Promise.allSettled(Array.from(dirs, async (dir) => {
+			const content = await this.readFile(`${this.repoPath}/${dir}${suffix}`);
+			return content ? [dir, content] : void 0;
+		}));
+		const nested = /* @__PURE__ */ new Map();
+		for (const entry of entries) {
+			const value = getSettledValue(entry);
+			if (value != null) nested.set(value[0], value[1]);
+		}
+		return nested;
 	}
-	async loadFile(target, path) {
+	async readFile(path) {
 		try {
 			const data = await this.fs.readFile(fileUri(path));
-			const content = new TextDecoder().decode(data);
-			if (content) target.add(content);
-		} catch {}
+			return new TextDecoder().decode(data);
+		} catch {
+			return;
+		}
+	}
+	async readInfoExclude() {
+		if (this.getInfoExcludePath == null) return this.readFile(`${this.gitDirPath}/info/exclude`);
+		try {
+			const path = await this.getInfoExcludePath();
+			return path != null ? await this.readFile(path) : void 0;
+		} catch {
+			return;
+		}
+	}
+	async readIgnoreCase() {
+		if (this.getIgnoreCase == null) return void 0;
+		try {
+			return await this.getIgnoreCase();
+		} catch {
+			return;
+		}
 	}
-	async loadGlobalExcludes(target) {
-		if (this.getGlobalExcludesPath == null) return;
+	async readGlobalExcludes() {
+		if (this.getGlobalExcludesPath == null) return void 0;
 		try {
 			const path = await this.getGlobalExcludesPath();
-			if (path != null) await this.loadFile(target, path);
-		} catch {}
+			return path != null ? await this.readFile(path) : void 0;
+		} catch {
+			return;
+		}
 	}
 };
 //#endregion

package/dist/git/watching/gitIgnoreFilter.js.map

@@ -1 +1 @@
-{"version":3,"file":"gitIgnoreFilter.js","names":[],"sources":["../../../../git/src/watching/gitIgnoreFilter.ts"],"sourcesContent":["import type { Ignore } from 'ignore';\nimport ignore from 'ignore';\nimport { getScopedCounter } from '@gitlens/utils/counter.js';\nimport { fileUri } from '@gitlens/utils/uri.js';\nimport type { FileSystemProvider } from '../context.js';\n\nexport interface GitIgnoreFilterOptions {\n\t/** Absolute path to the repository root (working tree) */\n\treadonly repoPath: string;\n\t/** Absolute path to the .git directory (for info/exclude) */\n\treadonly gitDirPath: string;\n\t/** File system provider for reading ignore files */\n\treadonly fs: FileSystemProvider;\n\t/**\n\t * Returns the path to the global excludes file (core.excludesFile).\n\t * May return undefined if not configured.\n\t */\n\treadonly getGlobalExcludesPath?: () => Promise<string | undefined>;\n}\n\n/**\n * In-memory gitignore filter using the `ignore` npm package.\n * Fully library-owned — no VS Code dependencies.\n *\n * Loads patterns eagerly on creation from:\n * 1. `<repoPath>/.gitignore`\n * 2. `<gitDirPath>/info/exclude`\n * 3. Global excludes file (`core.excludesFile`)\n *\n * Once loaded, all checks are **synchronous** for maximum performance.\n * Call `ready()` before first use to ensure patterns are loaded.\n */\nexport class GitIgnoreFilter {\n\tprivate ig: Ignore = ignore();\n\tprivate loading: Promise<void> | undefined;\n\tprivate readonly _generation = getScopedCounter();\n\n\tprivate readonly repoPath: string;\n\tprivate readonly gitDirPath: string;\n\tprivate readonly fs: FileSystemProvider;\n\tprivate readonly getGlobalExcludesPath?: () => Promise<string | undefined>;\n\n\tconstructor(options: GitIgnoreFilterOptions) {\n\t\tthis.repoPath = options.repoPath;\n\t\tthis.gitDirPath = options.gitDirPath;\n\t\tthis.fs = options.fs;\n\t\tthis.getGlobalExcludesPath = options.getGlobalExcludesPath;\n\n\t\t// Start loading immediately\n\t\tthis.loading = this.loadPatterns();\n\t}\n\n\t/** Resolves when patterns are loaded. Safe to call multiple times. */\n\tasync ready(): Promise<void> {\n\t\tif (this.loading != null) {\n\t\t\tawait this.loading;\n\t\t}\n\t}\n\n\t/**\n\t * Check if a path is ignored. Must be called after `ready()`.\n\t * @param relativePath Path relative to the repository root (forward slashes)\n\t * @returns true if the path should be ignored\n\t */\n\tisIgnored(relativePath: string): boolean {\n\t\tif (!relativePath) return false;\n\n\t\ttry {\n\t\t\treturn this.ig.ignores(relativePath);\n\t\t} catch {\n\t\t\t// `ignore` can throw on edge-case paths\n\t\t\treturn false;\n\t\t}\n\t}\n\n\t/**\n\t * Filter an array of relative paths, returning only non-ignored ones.\n\t * Must be called after `ready()`.\n\t */\n\tfilter(relativePaths: readonly string[]): string[] {\n\t\treturn this.ig.filter(relativePaths);\n\t}\n\n\t/**\n\t * Reload all patterns (e.g., after .gitignore or info/exclude changes).\n\t * Returns a promise that resolves when reload is complete.\n\t */\n\tasync refresh(): Promise<void> {\n\t\tthis.loading = this.loadPatterns();\n\t\tawait this.loading;\n\t}\n\n\tprivate async loadPatterns(): Promise<void> {\n\t\tconst id = this._generation.next();\n\t\tconst newIg = ignore();\n\n\t\tawait Promise.allSettled([\n\t\t\tthis.loadFile(newIg, `${this.repoPath}/.gitignore`),\n\t\t\tthis.loadFile(newIg, `${this.gitDirPath}/info/exclude`),\n\t\t\tthis.loadGlobalExcludes(newIg),\n\t\t]);\n\n\t\t// Only commit results if no newer refresh has started\n\t\tif (id !== this._generation.current) return;\n\n\t\tthis.ig = newIg;\n\t\tthis.loading = undefined;\n\t}\n\n\tprivate async loadFile(target: Ignore, path: string): Promise<void> {\n\t\ttry {\n\t\t\tconst data = await this.fs.readFile(fileUri(path));\n\t\t\tconst content = new TextDecoder().decode(data);\n\t\t\tif (content) {\n\t\t\t\ttarget.add(content);\n\t\t\t}\n\t\t} catch {\n\t\t\t// File might not exist or be unreadable — that's fine\n\t\t}\n\t}\n\n\tprivate async loadGlobalExcludes(target: Ignore): Promise<void> {\n\t\tif (this.getGlobalExcludesPath == null) return;\n\n\t\ttry {\n\t\t\tconst path = await this.getGlobalExcludesPath();\n\t\t\tif (path != null) {\n\t\t\t\tawait this.loadFile(target, path);\n\t\t\t}\n\t\t} catch {\n\t\t\t// Global excludes might not be configured\n\t\t}\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgCA,IAAa,kBAAb,MAA6B;CAC5B,KAAqB,OAAO;CAC5B;CACA,cAA+B,iBAAiB;CAEhD;CACA;CACA;CACA;CAEA,YAAY,SAAiC;EAC5C,KAAK,WAAW,QAAQ;EACxB,KAAK,aAAa,QAAQ;EAC1B,KAAK,KAAK,QAAQ;EAClB,KAAK,wBAAwB,QAAQ;EAGrC,KAAK,UAAU,KAAK,aAAa;CAClC;;CAGA,MAAM,QAAuB;EAC5B,IAAI,KAAK,WAAW,MACnB,MAAM,KAAK;CAEb;;;;;;CAOA,UAAU,cAA+B;EACxC,IAAI,CAAC,cAAc,OAAO;EAE1B,IAAI;GACH,OAAO,KAAK,GAAG,QAAQ,YAAY;EACpC,QAAQ;GAEP,OAAO;EACR;CACD;;;;;CAMA,OAAO,eAA4C;EAClD,OAAO,KAAK,GAAG,OAAO,aAAa;CACpC;;;;;CAMA,MAAM,UAAyB;EAC9B,KAAK,UAAU,KAAK,aAAa;EACjC,MAAM,KAAK;CACZ;CAEA,MAAc,eAA8B;EAC3C,MAAM,KAAK,KAAK,YAAY,KAAK;EACjC,MAAM,QAAQ,OAAO;EAErB,MAAM,QAAQ,WAAW;GACxB,KAAK,SAAS,OAAO,GAAG,KAAK,SAAS,YAAY;GAClD,KAAK,SAAS,OAAO,GAAG,KAAK,WAAW,cAAc;GACtD,KAAK,mBAAmB,KAAK;EAC9B,CAAC;EAGD,IAAI,OAAO,KAAK,YAAY,SAAS;EAErC,KAAK,KAAK;EACV,KAAK,UAAU,KAAA;CAChB;CAEA,MAAc,SAAS,QAAgB,MAA6B;EACnE,IAAI;GACH,MAAM,OAAO,MAAM,KAAK,GAAG,SAAS,QAAQ,IAAI,CAAC;GACjD,MAAM,UAAU,IAAI,YAAY,CAAC,CAAC,OAAO,IAAI;GAC7C,IAAI,SACH,OAAO,IAAI,OAAO;EAEpB,QAAQ,CAER;CACD;CAEA,MAAc,mBAAmB,QAA+B;EAC/D,IAAI,KAAK,yBAAyB,MAAM;EAExC,IAAI;GACH,MAAM,OAAO,MAAM,KAAK,sBAAsB;GAC9C,IAAI,QAAQ,MACX,MAAM,KAAK,SAAS,QAAQ,IAAI;EAElC,QAAQ,CAER;CACD;AACD"}
+{"version":3,"file":"gitIgnoreFilter.js","names":[],"sources":["../../../../git/src/watching/gitIgnoreFilter.ts"],"sourcesContent":["import type { Ignore } from 'ignore';\nimport ignore from 'ignore';\nimport { getScopedCounter } from '@gitlens/utils/counter.js';\nimport { isLinux } from '@gitlens/utils/platform.js';\nimport { getSettledValue } from '@gitlens/utils/promise.js';\nimport { fileUri } from '@gitlens/utils/uri.js';\nimport type { FileSystemProvider } from '../context.js';\n\n/**\n * Case sensitivity when `core.ignorecase` is unset or unreadable. `ignore` matches case-insensitively by default, but\n * git follows `core.ignorecase` — false on Linux (and on a case-sensitive macOS volume), where matching `Build/`\n * against `build/` would call a real change ignored and drop it.\n */\nconst defaultIgnoreCase = !isLinux;\n\nexport interface GitIgnoreFilterOptions {\n\t/** Absolute path to the repository root (working tree) */\n\treadonly repoPath: string;\n\t/** Absolute path to the .git directory (for info/exclude when `getInfoExcludePath` isn't provided) */\n\treadonly gitDirPath: string;\n\t/** File system provider for reading ignore files */\n\treadonly fs: FileSystemProvider;\n\t/**\n\t * Returns the path to the global excludes file (core.excludesFile).\n\t * May return undefined if not configured.\n\t */\n\treadonly getGlobalExcludesPath?: () => Promise<string | undefined>;\n\t/**\n\t * Returns the absolute path to `info/exclude`, which lives in the COMMON git dir for a linked worktree.\n\t * When provided, replaces the `gitDirPath`-based resolution; undefined means there is none to read.\n\t */\n\treadonly getInfoExcludePath?: () => Promise<string | undefined>;\n\t/**\n\t * Returns the repo-relative, `/`-separated paths of every `.gitignore` git reads (root included).\n\t * Without it, only the root `.gitignore` is honoured.\n\t */\n\treadonly getGitIgnorePaths?: () => Promise<readonly string[]>;\n\t/**\n\t * Returns `core.ignorecase`, which decides whether patterns match case-insensitively. Undefined (or a failed read)\n\t * falls back to the platform default (case-sensitive on Linux only).\n\t */\n\treadonly getIgnoreCase?: () => Promise<boolean | undefined>;\n}\n\n/**\n * In-memory gitignore filter using the `ignore` npm package.\n * Fully library-owned — no VS Code dependencies.\n *\n * Loads patterns eagerly on creation, in git's precedence order (lowest first):\n * 1. Global excludes file (`core.excludesFile`)\n * 2. `info/exclude`\n * 3. `<repoPath>/.gitignore`\n * 4. Nested `.gitignore` files (via `getGitIgnorePaths`), deeper overriding shallower\n *\n * Once loaded, all checks are **synchronous** for maximum performance.\n * Call `ready()` before first use to ensure patterns are loaded.\n */\nexport class GitIgnoreFilter {\n\tprivate ig: Ignore = ignore({ ignorecase: defaultIgnoreCase });\n\t/** Matchers for nested `.gitignore` files, keyed by their repo-relative directory (no trailing slash) */\n\tprivate nested: Map<string, Ignore> | undefined;\n\t/** The newest load, which {@link ready} waits for; cleared once it settles */\n\tprivate loading: Promise<void> | undefined;\n\t/** The load running now; at most one runs at a time */\n\tprivate inflight: Promise<void> | undefined;\n\t/** The one load queued behind {@link inflight}, which every refresh made meanwhile shares */\n\tprivate trailing: Promise<void> | undefined;\n\tprivate readonly _generation = getScopedCounter();\n\n\t// Reused across `isIgnored` calls (which are synchronous, so never interleave) to avoid per-event allocations\n\tprivate readonly _scratchMatchers: Ignore[] = [];\n\tprivate readonly _scratchBases: number[] = [];\n\n\tprivate readonly repoPath: string;\n\tprivate readonly gitDirPath: string;\n\tprivate readonly fs: FileSystemProvider;\n\tprivate readonly getGlobalExcludesPath?: () => Promise<string | undefined>;\n\tprivate readonly getInfoExcludePath?: () => Promise<string | undefined>;\n\tprivate readonly getGitIgnorePaths?: () => Promise<readonly string[]>;\n\tprivate readonly getIgnoreCase?: () => Promise<boolean | undefined>;\n\n\tconstructor(options: GitIgnoreFilterOptions) {\n\t\tthis.repoPath = options.repoPath;\n\t\tthis.gitDirPath = options.gitDirPath;\n\t\tthis.fs = options.fs;\n\t\tthis.getGlobalExcludesPath = options.getGlobalExcludesPath;\n\t\tthis.getInfoExcludePath = options.getInfoExcludePath;\n\t\tthis.getGitIgnorePaths = options.getGitIgnorePaths;\n\t\tthis.getIgnoreCase = options.getIgnoreCase;\n\n\t\t// Start loading immediately\n\t\tvoid this.startLoad();\n\t}\n\n\t/** Resolves when patterns are loaded. Safe to call multiple times. */\n\tasync ready(): Promise<void> {\n\t\tif (this.loading != null) {\n\t\t\tawait this.loading;\n\t\t}\n\t}\n\n\t/**\n\t * Check if a path is ignored. Must be called after `ready()`.\n\t * Errs toward \"not ignored\": a false \"ignored\" drops a real change, a false \"not ignored\" only costs a refresh.\n\t * @param relativePath Path relative to the repository root (forward slashes; a trailing slash marks a directory)\n\t * @returns true if the path should be ignored\n\t */\n\tisIgnored(relativePath: string): boolean {\n\t\tif (!relativePath) return false;\n\n\t\ttry {\n\t\t\tif (this.nested == null) return this.ig.ignores(relativePath);\n\n\t\t\treturn this.isIgnoredNested(relativePath, this.nested);\n\t\t} catch {\n\t\t\t// `ignore` can throw on edge-case paths\n\t\t\treturn false;\n\t\t}\n\t}\n\n\t/**\n\t * Filter an array of relative paths, returning only non-ignored ones.\n\t * Must be called after `ready()`.\n\t */\n\tfilter(relativePaths: readonly string[]): string[] {\n\t\treturn relativePaths.filter(p => !this.isIgnored(p));\n\t}\n\n\t/**\n\t * Reload all patterns (e.g., after a .gitignore or info/exclude changes), rediscovering nested `.gitignore` files.\n\t * Returns a promise that resolves when a reload started after this call is complete.\n\t *\n\t * Single-flight: an idle filter reloads at once, but while a reload runs, every further call shares one reload\n\t * queued behind it — a checkout touching many `.gitignore` files costs two reloads, not one per file.\n\t */\n\trefresh(): Promise<void> {\n\t\tif (this.inflight == null) return this.startLoad();\n\n\t\tif (this.trailing == null) {\n\t\t\tconst run = (): Promise<void> => {\n\t\t\t\tthis.trailing = undefined;\n\t\t\t\treturn this.startLoad();\n\t\t\t};\n\t\t\tthis.trailing = this.inflight.then(run, run);\n\t\t}\n\t\tthis.loading = this.trailing;\n\t\treturn this.trailing;\n\t}\n\n\tprivate startLoad(): Promise<void> {\n\t\tconst load: Promise<void> = this.loadPatterns().finally(() => {\n\t\t\tif (this.inflight === load) {\n\t\t\t\tthis.inflight = undefined;\n\t\t\t}\n\t\t\tif (this.loading === load) {\n\t\t\t\tthis.loading = undefined;\n\t\t\t}\n\t\t});\n\t\tthis.inflight = load;\n\t\tthis.loading = load;\n\t\treturn load;\n\t}\n\n\t/**\n\t * Mirrors git's directory walk: each ancestor directory is checked shallow→deep, and the first one found ignored\n\t * ignores the whole path (git never descends into it, so nothing below can re-include it). At each level, the\n\t * matchers whose directory is a proper ancestor apply, and the deepest decisive one wins, falling back to the root.\n\t */\n\tprivate isIgnoredNested(path: string, nested: Map<string, Ignore>): boolean {\n\t\tconst matchers = this._scratchMatchers;\n\t\tconst bases = this._scratchBases;\n\n\t\ttry {\n\t\t\t// A trailing slash belongs to the path itself (a directory form), not to an ancestor\n\t\t\tconst last = path.length - 1;\n\n\t\t\tlet slash = path.indexOf('/');\n\t\t\twhile (slash !== -1 && slash < last) {\n\t\t\t\tif (this.isLevelIgnored(path, slash + 1, matchers, bases)) return true;\n\n\t\t\t\t// A directory's own `.gitignore` applies below it, never to the directory itself\n\t\t\t\tconst matcher = nested.get(path.slice(0, slash));\n\t\t\t\tif (matcher != null) {\n\t\t\t\t\tmatchers.push(matcher);\n\t\t\t\t\tbases.push(slash + 1);\n\t\t\t\t}\n\n\t\t\t\tslash = path.indexOf('/', slash + 1);\n\t\t\t}\n\n\t\t\treturn this.isLevelIgnored(path, path.length, matchers, bases);\n\t\t} finally {\n\t\t\tmatchers.length = 0;\n\t\t\tbases.length = 0;\n\t\t}\n\t}\n\n\t/** Whether `path.slice(0, end)` is ignored, given its ancestors aren't */\n\tprivate isLevelIgnored(path: string, end: number, matchers: readonly Ignore[], bases: readonly number[]): boolean {\n\t\tfor (let i = matchers.length - 1; i >= 0; i--) {\n\t\t\tconst verdict = this.testLevel(matchers[i], path.slice(bases[i], end));\n\t\t\tif (verdict != null) return verdict;\n\t\t}\n\n\t\treturn this.testLevel(this.ig, path.slice(0, end)) ?? false;\n\t}\n\n\t/** Returns the matcher's decisive verdict for `path`, or undefined when it has none */\n\tprivate testLevel(matcher: Ignore, path: string): boolean | undefined {\n\t\tconst result = matcher.test(path);\n\t\tif (result.unignored) return false;\n\t\tif (!result.ignored) return undefined;\n\n\t\t// `ignore` folds its own verdict for each ancestor into a path's result: once the matcher considers a parent\n\t\t// ignored, every child reports that parent's result. Reaching here means a deeper matcher re-included that\n\t\t// parent, so this result says nothing about the path itself — the matcher's own rules are unknowable, so\n\t\t// answer \"not ignored\" rather than risk dropping a real change.\n\t\tconst parentEnd = path.lastIndexOf('/', path.length - 2);\n\t\tif (parentEnd !== -1 && matcher.test(path.slice(0, parentEnd + 1)).ignored) return false;\n\n\t\treturn true;\n\t}\n\n\tprivate async loadPatterns(): Promise<void> {\n\t\tconst id = this._generation.next();\n\n\t\tconst [globalResult, infoResult, rootResult, nestedResult, ignoreCaseResult] = await Promise.allSettled([\n\t\t\tthis.readGlobalExcludes(),\n\t\t\tthis.readInfoExclude(),\n\t\t\tthis.readFile(`${this.repoPath}/.gitignore`),\n\t\t\tthis.loadNested(),\n\t\t\tthis.readIgnoreCase(),\n\t\t]);\n\n\t\t// Only commit results if no newer refresh has started\n\t\tif (id !== this._generation.current) return;\n\n\t\tconst options = { ignorecase: getSettledValue(ignoreCaseResult) ?? defaultIgnoreCase };\n\n\t\t// Added in git's precedence order (lowest first), since the last matching pattern wins\n\t\tconst ig = ignore(options);\n\t\tfor (const content of [\n\t\t\tgetSettledValue(globalResult),\n\t\t\tgetSettledValue(infoResult),\n\t\t\tgetSettledValue(rootResult),\n\t\t]) {\n\t\t\tif (!content) continue;\n\n\t\t\ttry {\n\t\t\t\tig.add(content);\n\t\t\t} catch {\n\t\t\t\t// A source `ignore` can't parse is skipped rather than failing the whole load\n\t\t\t}\n\t\t}\n\n\t\tlet nested: Map<string, Ignore> | undefined;\n\t\tconst nestedContents = getSettledValue(nestedResult);\n\t\tif (nestedContents?.size) {\n\t\t\tnested = new Map();\n\t\t\tfor (const [dir, content] of nestedContents) {\n\t\t\t\ttry {\n\t\t\t\t\tnested.set(dir, ignore(options).add(content));\n\t\t\t\t} catch {\n\t\t\t\t\t// A file `ignore` can't parse is skipped rather than failing the whole load\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tthis.ig = ig;\n\t\tthis.nested = nested?.size ? nested : undefined;\n\t}\n\n\t/** Reads every nested `.gitignore`, keyed by its repo-relative directory (no trailing slash) */\n\tprivate async loadNested(): Promise<Map<string, string> | undefined> {\n\t\tif (this.getGitIgnorePaths == null) return undefined;\n\n\t\tlet paths: readonly string[];\n\t\ttry {\n\t\t\tpaths = await this.getGitIgnorePaths();\n\t\t} catch {\n\t\t\t// Discovery failed — fall back to the root `.gitignore` alone\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst suffix = '/.gitignore';\n\t\tconst dirs = new Set<string>();\n\t\tfor (const path of paths) {\n\t\t\t// The root `.gitignore` (no directory) is loaded with the other root sources\n\t\t\tif (path.length <= suffix.length || !path.endsWith(suffix)) continue;\n\n\t\t\tdirs.add(path.slice(0, -suffix.length));\n\t\t}\n\t\tif (!dirs.size) return undefined;\n\n\t\tconst entries = await Promise.allSettled(\n\t\t\tArray.from(dirs, async dir => {\n\t\t\t\tconst content = await this.readFile(`${this.repoPath}/${dir}${suffix}`);\n\t\t\t\treturn content ? ([dir, content] as const) : undefined;\n\t\t\t}),\n\t\t);\n\n\t\tconst nested = new Map<string, string>();\n\t\tfor (const entry of entries) {\n\t\t\tconst value = getSettledValue(entry);\n\t\t\tif (value != null) {\n\t\t\t\tnested.set(value[0], value[1]);\n\t\t\t}\n\t\t}\n\t\treturn nested;\n\t}\n\n\tprivate async readFile(path: string): Promise<string | undefined> {\n\t\ttry {\n\t\t\tconst data = await this.fs.readFile(fileUri(path));\n\t\t\treturn new TextDecoder().decode(data);\n\t\t} catch {\n\t\t\t// File might not exist or be unreadable — that's fine\n\t\t\treturn undefined;\n\t\t}\n\t}\n\n\tprivate async readInfoExclude(): Promise<string | undefined> {\n\t\tif (this.getInfoExcludePath == null) return this.readFile(`${this.gitDirPath}/info/exclude`);\n\n\t\ttry {\n\t\t\tconst path = await this.getInfoExcludePath();\n\t\t\treturn path != null ? await this.readFile(path) : undefined;\n\t\t} catch {\n\t\t\t// The git dir couldn't be resolved\n\t\t\treturn undefined;\n\t\t}\n\t}\n\n\tprivate async readIgnoreCase(): Promise<boolean | undefined> {\n\t\tif (this.getIgnoreCase == null) return undefined;\n\n\t\ttry {\n\t\t\treturn await this.getIgnoreCase();\n\t\t} catch {\n\t\t\t// Unreadable — the platform default applies\n\t\t\treturn undefined;\n\t\t}\n\t}\n\n\tprivate async readGlobalExcludes(): Promise<string | undefined> {\n\t\tif (this.getGlobalExcludesPath == null) return undefined;\n\n\t\ttry {\n\t\t\tconst path = await this.getGlobalExcludesPath();\n\t\t\treturn path != null ? await this.readFile(path) : undefined;\n\t\t} catch {\n\t\t\t// Global excludes might not be configured\n\t\t\treturn undefined;\n\t\t}\n\t}\n}\n"],"mappings":"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"}

package/dist/git/watching/initWatcher.d.ts

@@ -3,7 +3,11 @@ import { Event } from "../../utils/event.js";
 import { FileWatchingProvider } from "./provider.js";
 //#region ../git/src/watching/initWatcher.d.ts
 export interface RepositoryInitEvent {
-  /** Absolute path of the created .git directory */
+  /**
+   * Absolute path of the created .git directory. After the watcher lost events (`overflow`), it is instead the base
+   * path or the subtree whose events were dropped — a `.git` may have been created anywhere beneath it, so the host
+   * rescans it for repositories.
+   */
   readonly path: string;
   /** Absolute path of the base directory being watched */
   readonly basePath: string;

package/dist/git/watching/initWatcher.js

@@ -38,7 +38,7 @@ var RepositoryInitWatcher = class {
 	watch(basePath) {
 		if (this._disposed || this.watchers.has(basePath)) return createDisposable(() => {});
 		const watcher = this.provider.createWatcher(basePath, gitInitGlob, (event) => {
-			if (event.reason !== "create") return;
+			if (event.reason !== "create" && event.reason !== "overflow") return;
 			this.emitter.fire({
 				path: event.path,
 				basePath

package/dist/git/watching/initWatcher.js.map

@@ -1 +1 @@
-{"version":3,"file":"initWatcher.js","names":[],"sources":["../../../../git/src/watching/initWatcher.ts"],"sourcesContent":["import type { UnifiedDisposable } from '@gitlens/utils/disposable.js';\nimport { createDisposable } from '@gitlens/utils/disposable.js';\nimport type { Event } from '@gitlens/utils/event.js';\nimport { Emitter } from '@gitlens/utils/event.js';\nimport type { FileWatcher, FileWatchingProvider } from './provider.js';\nimport { gitInitGlob } from './watcherPatterns.js';\n\nexport interface RepositoryInitEvent {\n\t/** Absolute path of the created .git directory */\n\treadonly path: string;\n\t/** Absolute path of the base directory being watched */\n\treadonly basePath: string;\n}\n\n/**\n * Watches for `.git` directory creation within watched base paths.\n * Used to discover new repositories when `git init` or `git clone` runs.\n *\n * This is separate from {@link RepositoryWatchService} which monitors\n * already-discovered repositories. The init watcher is a pre-discovery\n * concern — it fires before a repository is known.\n */\nexport class RepositoryInitWatcher implements UnifiedDisposable {\n\tprivate readonly provider: FileWatchingProvider;\n\tprivate readonly emitter = new Emitter<RepositoryInitEvent>();\n\tprivate readonly watchers = new Map<string, FileWatcher>();\n\tprivate _disposed = false;\n\n\tconstructor(provider: FileWatchingProvider) {\n\t\tthis.provider = provider;\n\t}\n\n\t[Symbol.dispose](): void {\n\t\tthis.dispose();\n\t}\n\n\tdispose(): void {\n\t\tif (this._disposed) return;\n\n\t\tthis._disposed = true;\n\n\t\tfor (const watcher of this.watchers.values()) {\n\t\t\twatcher.dispose();\n\t\t}\n\t\tthis.watchers.clear();\n\t\tthis.emitter.dispose();\n\t}\n\n\tget onDidCreate(): Event<RepositoryInitEvent> {\n\t\treturn this.emitter.event;\n\t}\n\n\t/**\n\t * Start watching a directory for `.git` creation.\n\t * Returns a disposable that stops watching that directory.\n\t */\n\twatch(basePath: string): UnifiedDisposable {\n\t\tif (this._disposed || this.watchers.has(basePath)) {\n\t\t\treturn createDisposable(() => {});\n\t\t}\n\n\t\tconst watcher = this.provider.createWatcher(basePath, gitInitGlob, event => {\n\t\t\tif (event.reason !== 'create') return;\n\n\t\t\tthis.emitter.fire({ path: event.path, basePath: basePath });\n\t\t});\n\n\t\tthis.watchers.set(basePath, watcher);\n\n\t\treturn createDisposable(\n\t\t\t() => {\n\t\t\t\tconst w = this.watchers.get(basePath);\n\t\t\t\tif (w === watcher) {\n\t\t\t\t\tthis.watchers.delete(basePath);\n\t\t\t\t\tw.dispose();\n\t\t\t\t}\n\t\t\t},\n\t\t\t{ once: true },\n\t\t);\n\t}\n}\n"],"mappings":";;;;;;;;;;;;AAsBA,IAAa,wBAAb,MAAgE;CAC/D;CACA,UAA2B,IAAI,QAA6B;CAC5D,2BAA4B,IAAI,IAAyB;CACzD,YAAoB;CAEpB,YAAY,UAAgC;EAC3C,KAAK,WAAW;CACjB;CAEA,CAAC,OAAO,WAAiB;EACxB,KAAK,QAAQ;CACd;CAEA,UAAgB;EACf,IAAI,KAAK,WAAW;EAEpB,KAAK,YAAY;EAEjB,KAAK,MAAM,WAAW,KAAK,SAAS,OAAO,GAC1C,QAAQ,QAAQ;EAEjB,KAAK,SAAS,MAAM;EACpB,KAAK,QAAQ,QAAQ;CACtB;CAEA,IAAI,cAA0C;EAC7C,OAAO,KAAK,QAAQ;CACrB;;;;;CAMA,MAAM,UAAqC;EAC1C,IAAI,KAAK,aAAa,KAAK,SAAS,IAAI,QAAQ,GAC/C,OAAO,uBAAuB,CAAC,CAAC;EAGjC,MAAM,UAAU,KAAK,SAAS,cAAc,UAAU,cAAa,UAAS;GAC3E,IAAI,MAAM,WAAW,UAAU;GAE/B,KAAK,QAAQ,KAAK;IAAE,MAAM,MAAM;IAAgB;GAAS,CAAC;EAC3D,CAAC;EAED,KAAK,SAAS,IAAI,UAAU,OAAO;EAEnC,OAAO,uBACA;GACL,MAAM,IAAI,KAAK,SAAS,IAAI,QAAQ;GACpC,IAAI,MAAM,SAAS;IAClB,KAAK,SAAS,OAAO,QAAQ;IAC7B,EAAE,QAAQ;GACX;EACD,GACA,EAAE,MAAM,KAAK,CACd;CACD;AACD"}
+{"version":3,"file":"initWatcher.js","names":[],"sources":["../../../../git/src/watching/initWatcher.ts"],"sourcesContent":["import type { UnifiedDisposable } from '@gitlens/utils/disposable.js';\nimport { createDisposable } from '@gitlens/utils/disposable.js';\nimport type { Event } from '@gitlens/utils/event.js';\nimport { Emitter } from '@gitlens/utils/event.js';\nimport type { FileWatcher, FileWatchingProvider } from './provider.js';\nimport { gitInitGlob } from './watcherPatterns.js';\n\nexport interface RepositoryInitEvent {\n\t/**\n\t * Absolute path of the created .git directory. After the watcher lost events (`overflow`), it is instead the base\n\t * path or the subtree whose events were dropped — a `.git` may have been created anywhere beneath it, so the host\n\t * rescans it for repositories.\n\t */\n\treadonly path: string;\n\t/** Absolute path of the base directory being watched */\n\treadonly basePath: string;\n}\n\n/**\n * Watches for `.git` directory creation within watched base paths.\n * Used to discover new repositories when `git init` or `git clone` runs.\n *\n * This is separate from {@link RepositoryWatchService} which monitors\n * already-discovered repositories. The init watcher is a pre-discovery\n * concern — it fires before a repository is known.\n */\nexport class RepositoryInitWatcher implements UnifiedDisposable {\n\tprivate readonly provider: FileWatchingProvider;\n\tprivate readonly emitter = new Emitter<RepositoryInitEvent>();\n\tprivate readonly watchers = new Map<string, FileWatcher>();\n\tprivate _disposed = false;\n\n\tconstructor(provider: FileWatchingProvider) {\n\t\tthis.provider = provider;\n\t}\n\n\t[Symbol.dispose](): void {\n\t\tthis.dispose();\n\t}\n\n\tdispose(): void {\n\t\tif (this._disposed) return;\n\n\t\tthis._disposed = true;\n\n\t\tfor (const watcher of this.watchers.values()) {\n\t\t\twatcher.dispose();\n\t\t}\n\t\tthis.watchers.clear();\n\t\tthis.emitter.dispose();\n\t}\n\n\tget onDidCreate(): Event<RepositoryInitEvent> {\n\t\treturn this.emitter.event;\n\t}\n\n\t/**\n\t * Start watching a directory for `.git` creation.\n\t * Returns a disposable that stops watching that directory.\n\t */\n\twatch(basePath: string): UnifiedDisposable {\n\t\tif (this._disposed || this.watchers.has(basePath)) {\n\t\t\treturn createDisposable(() => {});\n\t\t}\n\n\t\tconst watcher = this.provider.createWatcher(basePath, gitInitGlob, event => {\n\t\t\tif (event.reason !== 'create' && event.reason !== 'overflow') return;\n\n\t\t\tthis.emitter.fire({ path: event.path, basePath: basePath });\n\t\t});\n\n\t\tthis.watchers.set(basePath, watcher);\n\n\t\treturn createDisposable(\n\t\t\t() => {\n\t\t\t\tconst w = this.watchers.get(basePath);\n\t\t\t\tif (w === watcher) {\n\t\t\t\t\tthis.watchers.delete(basePath);\n\t\t\t\t\tw.dispose();\n\t\t\t\t}\n\t\t\t},\n\t\t\t{ once: true },\n\t\t);\n\t}\n}\n"],"mappings":";;;;;;;;;;;;AA0BA,IAAa,wBAAb,MAAgE;CAC/D;CACA,UAA2B,IAAI,QAA6B;CAC5D,2BAA4B,IAAI,IAAyB;CACzD,YAAoB;CAEpB,YAAY,UAAgC;EAC3C,KAAK,WAAW;CACjB;CAEA,CAAC,OAAO,WAAiB;EACxB,KAAK,QAAQ;CACd;CAEA,UAAgB;EACf,IAAI,KAAK,WAAW;EAEpB,KAAK,YAAY;EAEjB,KAAK,MAAM,WAAW,KAAK,SAAS,OAAO,GAC1C,QAAQ,QAAQ;EAEjB,KAAK,SAAS,MAAM;EACpB,KAAK,QAAQ,QAAQ;CACtB;CAEA,IAAI,cAA0C;EAC7C,OAAO,KAAK,QAAQ;CACrB;;;;;CAMA,MAAM,UAAqC;EAC1C,IAAI,KAAK,aAAa,KAAK,SAAS,IAAI,QAAQ,GAC/C,OAAO,uBAAuB,CAAC,CAAC;EAGjC,MAAM,UAAU,KAAK,SAAS,cAAc,UAAU,cAAa,UAAS;GAC3E,IAAI,MAAM,WAAW,YAAY,MAAM,WAAW,YAAY;GAE9D,KAAK,QAAQ,KAAK;IAAE,MAAM,MAAM;IAAgB;GAAS,CAAC;EAC3D,CAAC;EAED,KAAK,SAAS,IAAI,UAAU,OAAO;EAEnC,OAAO,uBACA;GACL,MAAM,IAAI,KAAK,SAAS,IAAI,QAAQ;GACpC,IAAI,MAAM,SAAS;IAClB,KAAK,SAAS,OAAO,QAAQ;IAC7B,EAAE,QAAQ;GACX;EACD,GACA,EAAE,MAAM,KAAK,CACd;CACD;AACD"}

package/dist/git/watching/provider.d.ts

@@ -1,24 +1,49 @@
 import { UnifiedDisposable } from "../../utils/disposable.js";
 //#region ../git/src/watching/provider.d.ts
-/** Event from a filesystem watcher */
+/**
+ * Event from a filesystem watcher.
+ *
+ * A reported directory path stands for everything beneath it: a watcher can miss the files of a just-created
+ * directory (it only sees the directory after its create event), but never the directory itself.
+ */
 export interface FileWatchEvent {
-  /** Absolute path of the changed file */
+  /** Absolute path of the changed file or directory; for `overflow`, the watcher's `basePath` or a subtree of it */
   readonly path: string;
-  readonly reason: 'create' | 'change' | 'delete';
+  /**
+   * `overflow`: events under `path` (the watcher's `basePath`, or a subtree of it) were dropped, so core rescans
+   * rather than trusting what it was told. Providers that can't lose events never emit it.
+   */
+  readonly reason: 'create' | 'change' | 'delete' | 'overflow';
 }
 /** Opaque token representing a filesystem watcher */
 export interface FileWatcher extends UnifiedDisposable {}
+export interface FileWatcherOptions {
+  /**
+   * Directories to leave unwatched, each with everything beneath it. Entries are `/`-separated and relative to
+   * `basePath`: a glob when it contains glob syntax (`build-*`), otherwise a literal path (`dist`,
+   * `packages/app/out`) — core never emits a literal containing glob metacharacters. A provider that can prune
+   * natively should (no OS watch, no events); one that can't may ignore this, since core filters events itself.
+   * (Map each entry to your backend's syntax — e.g. picomatch-based watchers need both `X` and `X/**`.)
+   */
+  readonly excludes?: readonly string[];
+}
 /**
  * Factory for creating filesystem watchers. The library calls this
- * with a base path + glob pattern; the caller creates platform-specific
- * watchers (e.g., VS Code's `workspace.createFileSystemWatcher`).
+ * with a base path + glob pattern (plus, optionally, directories to prune);
+ * the caller creates platform-specific watchers (e.g., VS Code's
+ * `workspace.createFileSystemWatcher`, or a native watcher such as `@parcel/watcher`).
  *
  * This is the only pluggable concern in the watching system.
- * Everything else (interpretation, gitignore, debouncing, etc.)
- * is fully library-owned.
+ * Everything else (interpretation, gitignore, debouncing, which directories
+ * to exclude, etc.) is fully library-owned.
  */
 export interface FileWatchingProvider {
-  createWatcher(basePath: string, pattern: string, onEvent: (event: FileWatchEvent) => void): FileWatcher;
+  createWatcher(basePath: string, pattern: string, onEvent: (event: FileWatchEvent) => void, options?: FileWatcherOptions): FileWatcher;
+  /**
+   * True when `createWatcher` prunes `options.excludes` natively. Core only spends git reads on the git-ignored
+   * set for a provider that can use it.
+   */
+  readonly supportsExcludes?: boolean;
 }
 //#endregion
 //# sourceMappingURL=provider.d.ts.map

package/dist/git/watching/watchGroup.d.ts

@@ -7,7 +7,11 @@ import { GitDir, RepositoryChange } from "../models/repository.js";
  * These are raw, un-debounced events — the session handles debouncing.
  */
 export interface WatchGroupHooks {
-  readonly onRepoChanged: (repoPath: string, changes: RepositoryChange[]) => void;
+  /**
+   * `ref` is the full ref name (or ref directory) or pseudo-ref (`HEAD`, `ORIG_HEAD`) whose file changed, with a
+   * trailing `.lock` stripped; `undefined` for any other `.git` file.
+   */
+  readonly onRepoChanged: (repoPath: string, changes: RepositoryChange[], ref?: string) => void;
   readonly onFetchHeadChanged?: (repoPath: string) => void;
   readonly onIgnoresChanged?: (repoPath: string) => void;
 }
@@ -19,6 +23,10 @@ interface SessionEntry {
   readonly repoPath: string;
   readonly gitDirPath: string;
   readonly rootWatcher: FileWatcher;
+  /** True when the root watcher is on the common dir itself, so it already sees every common file */
+  readonly coversCommon: boolean;
+  /** For a linked session, its `<n>` in `<common>/worktrees/<n>`; otherwise `undefined` */
+  readonly worktreeId: string | undefined;
   readonly hooks: WatchGroupHooks;
 }
 /**
@@ -26,7 +34,8 @@ interface SessionEntry {
  * shared across all worktrees that reference it.
  *
  * Structure:
- * - 1 common watcher: config, refs/**, info/exclude, etc.
+ * - 1 common watcher: config, refs/**, info/exclude, etc. Delivers to linked sessions only; a
+ *   session rooted at the common dir hears the same files from its own combined root watcher.
  * - N root watchers: one per worktree (index, HEAD, *_HEAD, etc.)
  *
  * For a standard (non-worktree) repo, the common and root directories
@@ -47,8 +56,10 @@ export declare class WatchGroup implements UnifiedDisposable {
   addSession(repoPath: string, gitDir: GitDir, hooks: WatchGroupHooks): void;
   /** Remove a session from this group. Disposes its root watcher. */
   removeSession(repoPath: string): void;
+  private getWorktreeId;
   private ensureCommonWatcher;
   private onCommonEvent;
+  private deliverOverflow;
   private onRootEvent;
 }
 //#endregion

package/dist/git/watching/watchGroup.js

@@ -1,13 +1,15 @@
+import { some } from "../../utils/iterable.js";
 import { isDescendant, relative } from "../../utils/path.js";
-import { dotGitGlobCombined, dotGitGlobCommon, dotGitGlobRoot, shouldIgnoreRepoPath } from "./watcherPatterns.js";
-import { classifyGitDirChange } from "./classifyChange.js";
+import { dotGitGlobCombined, dotGitGlobCommon, dotGitGlobRoot, gitDirExcludes, shouldIgnoreRepoPath } from "./watcherPatterns.js";
+import { allWatchedRepositoryChanges, classifyGitDirChange } from "./classifyChange.js";
 //#region ../git/src/watching/watchGroup.ts
 /**
 * Manages filesystem watchers for a single physical `.git` directory,
 * shared across all worktrees that reference it.
 *
 * Structure:
-* - 1 common watcher: config, refs/**, info/exclude, etc.
+* - 1 common watcher: config, refs/**, info/exclude, etc. Delivers to linked sessions only; a
+*   session rooted at the common dir hears the same files from its own combined root watcher.
 * - N root watchers: one per worktree (index, HEAD, *_HEAD, etc.)
 *
 * For a standard (non-worktree) repo, the common and root directories
@@ -47,11 +49,14 @@ var WatchGroup = class {
 		const rootWatcher = this.provider.createWatcher(gitDir.uri.fsPath, rootPattern, (event) => {
 			const entry = this._sessions.get(repoPath);
 			if (entry != null) this.onRootEvent(event, entry);
-		});
+		}, { excludes: gitDirExcludes });
+		const entryGitDirPath = gitDir.uri.fsPath;
 		const entry = {
 			repoPath,
-			gitDirPath: gitDir.uri.fsPath,
+			gitDirPath: entryGitDirPath,
 			rootWatcher,
+			coversCommon: isStandard,
+			worktreeId: isStandard ? void 0 : this.getWorktreeId(entryGitDirPath),
 			hooks
 		};
 		this._sessions.set(repoPath, entry);
@@ -63,32 +68,65 @@ var WatchGroup = class {
 		if (entry == null) return;
 		entry.rootWatcher.dispose();
 		this._sessions.delete(repoPath);
-		if (this._sessions.size === 0 && this._commonWatcher != null) {
+		if (this._commonWatcher != null && !some(this._sessions.values(), (e) => !e.coversCommon)) {
 			this._commonWatcher.dispose();
 			this._commonWatcher = void 0;
 		}
 	}
+	getWorktreeId(gitDirPath) {
+		if (!isDescendant(gitDirPath, this.commonGitDir)) return void 0;
+		const rel = relative(this.commonGitDir, gitDirPath);
+		if (!rel.startsWith("worktrees/")) return void 0;
+		const id = rel.substring(10);
+		return id.length > 0 && !id.includes("/") ? id : void 0;
+	}
 	ensureCommonWatcher() {
 		if (this._commonWatcher != null || this._disposed) return;
 		this._commonWatcher = this.provider.createWatcher(this.commonGitDir, dotGitGlobCommon, (event) => {
 			this.onCommonEvent(event);
-		});
+		}, { excludes: gitDirExcludes });
 	}
 	onCommonEvent(event) {
+		if (event.reason === "overflow") {
+			for (const entry of this._sessions.values()) {
+				if (entry.coversCommon) continue;
+				this.deliverOverflow(entry);
+			}
+			return;
+		}
 		if (!isDescendant(event.path, this.commonGitDir)) return;
 		const relativePath = relative(this.commonGitDir, event.path);
 		if (shouldIgnoreRepoPath(relativePath)) return;
-		if (relativePath === "FETCH_HEAD") {
-			for (const entry of this._sessions.values()) entry.hooks.onFetchHeadChanged?.(entry.repoPath);
-			return;
+		const isFetchHead = relativePath === "FETCH_HEAD";
+		const isExclude = relativePath === "info/exclude";
+		const changes = isFetchHead ? void 0 : classifyGitDirChange(relativePath);
+		if (changes == null && !isFetchHead && !isExclude) return;
+		const ref = changes != null ? getChangedRef(relativePath) : void 0;
+		let ownerId;
+		if (changes != null && relativePath.length > 10 && relativePath.startsWith("worktrees/")) {
+			const idEnd = relativePath.indexOf("/", 10);
+			if (idEnd !== -1 && relativePath.substring(idEnd + 1) === "HEAD") ownerId = relativePath.substring(10, idEnd);
 		}
-		const changes = classifyGitDirChange(relativePath);
 		for (const entry of this._sessions.values()) {
-			if (changes != null) entry.hooks.onRepoChanged(entry.repoPath, changes);
-			if (relativePath === "info/exclude") entry.hooks.onIgnoresChanged?.(entry.repoPath);
+			if (entry.coversCommon) continue;
+			if (isFetchHead) {
+				entry.hooks.onFetchHeadChanged?.(entry.repoPath);
+				continue;
+			}
+			if (changes != null && (ownerId == null || entry.worktreeId !== ownerId)) entry.hooks.onRepoChanged(entry.repoPath, changes, ref);
+			if (isExclude) entry.hooks.onIgnoresChanged?.(entry.repoPath);
 		}
 	}
+	deliverOverflow(entry) {
+		entry.hooks.onRepoChanged(entry.repoPath, [...allWatchedRepositoryChanges]);
+		entry.hooks.onFetchHeadChanged?.(entry.repoPath);
+		entry.hooks.onIgnoresChanged?.(entry.repoPath);
+	}
 	onRootEvent(event, entry) {
+		if (event.reason === "overflow") {
+			this.deliverOverflow(entry);
+			return;
+		}
 		if (!isDescendant(event.path, entry.gitDirPath)) return;
 		const relativePath = relative(entry.gitDirPath, event.path);
 		if (shouldIgnoreRepoPath(relativePath)) return;
@@ -97,10 +135,18 @@ var WatchGroup = class {
 			return;
 		}
 		const changes = classifyGitDirChange(relativePath);
-		if (changes != null) entry.hooks.onRepoChanged(entry.repoPath, changes);
+		if (changes != null) entry.hooks.onRepoChanged(entry.repoPath, changes, getChangedRef(relativePath));
 		if (relativePath === "info/exclude") entry.hooks.onIgnoresChanged?.(entry.repoPath);
 	}
 };
+/**
+* The ref a `.git`-relative path names: a loose ref (or ref directory) under `refs/`, or the `HEAD`/`ORIG_HEAD`
+* pseudo-refs. Git writes a ref as `<name>.lock` and renames it over `<name>`, so the lock file names the same ref.
+*/
+function getChangedRef(relativePath) {
+	const ref = relativePath.endsWith(".lock") ? relativePath.substring(0, relativePath.length - 5) : relativePath;
+	return ref.startsWith("refs/") || ref === "HEAD" || ref === "ORIG_HEAD" ? ref : void 0;
+}
 //#endregion
 export { WatchGroup };