@gitkraken/core-gitlens 0.12.0 → 0.14.0

package/dist/git/watching/gitDirPoller.js

@@ -0,0 +1,266 @@
+import { isDescendant, joinPaths, relative } from "../../utils/path.js";
+//#region ../git/src/watching/gitDirPoller.ts
+const defaultPollIntervalMs = 6e4;
+const defaultPollActiveCheckMs = 5e3;
+const defaultPollConcurrency = 4;
+/**
+* Runs passes over the poll targets of every watcher that can't be trusted, reading at most 4 targets at once across
+* passes and first readings. A target is read once soon after it is added, so its baseline doesn't wait for the next
+* pass; targets added together are read together.
+*
+* With the default gate (no `isActive`), one timer runs a pass every `intervalMs`, stopped by {@link suspend} and
+* restarted by {@link resume}, which runs a pass at once. With a host's `isActive`, whose changes core can't see, one
+* timer looks at it every `activeCheckMs`: a pass is due once `intervalMs` has gone by since the last one, or at the
+* first look after the gate opens (or after {@link nudge}), so a window that comes back between passes doesn't wait out
+* the rest of one.
+*/
+var GitDirPoller = class {
+	options;
+	targets = /* @__PURE__ */ new Set();
+	/** Targets added since the last pass and not yet read */
+	unread = /* @__PURE__ */ new Set();
+	/** Each target's last read asked for; a target is never read twice at once, so the next waits for it */
+	reading = /* @__PURE__ */ new Map();
+	/** Reads waiting for one of the {@link defaultPollConcurrency} slots, which a finished read hands over */
+	waiting = [];
+	/**
+	* The stats of the batches (a pass, or first readings) in flight, shared by every target that probes the same path,
+	* as the main checkout's root and its common dir do
+	*/
+	stats = /* @__PURE__ */ new Map();
+	intervalMs;
+	activeCheckMs;
+	timer;
+	running;
+	batches = 0;
+	slotsInUse = 0;
+	/** The next look runs a pass whatever the interval says */
+	due = true;
+	lastPassAt = 0;
+	suspended = false;
+	disposed = false;
+	constructor(options) {
+		this.options = options;
+		this.intervalMs = options.intervalMs ?? defaultPollIntervalMs;
+		this.activeCheckMs = options.activeCheckMs ?? defaultPollActiveCheckMs;
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+	dispose() {
+		this.disposed = true;
+		this.targets.clear();
+		this.unread.clear();
+		this.stats.clear();
+		this.stopTimer();
+	}
+	get size() {
+		return this.targets.size;
+	}
+	add(target) {
+		if (this.disposed || this.targets.has(target)) return;
+		this.targets.add(target);
+		this.unread.add(target);
+		if (this.unread.size === 1) queueMicrotask(() => this.readUnread());
+		this.startTimer();
+	}
+	delete(target) {
+		this.unread.delete(target);
+		if (!this.targets.delete(target) || this.targets.size !== 0) return;
+		this.stopTimer();
+	}
+	/** Makes the next look a pass, and looks now */
+	nudge() {
+		this.due = true;
+		this.tick();
+	}
+	/** Under the default gate, stops passes (and the timer) until {@link resume}; a host's `isActive` ignores it */
+	suspend() {
+		this.suspended = true;
+		if (this.options.isActive == null) this.stopTimer();
+	}
+	/** Lifts {@link suspend}, and runs a pass now, so what moved meanwhile is polled rather than at the next look */
+	resume() {
+		this.suspended = false;
+		this.nudge();
+	}
+	/** One look at the gate: runs a pass when one is due, the gate is open and none is in flight */
+	tick() {
+		if (this.disposed || this.targets.size === 0) return Promise.resolve();
+		if (!(this.options.isActive?.() ?? !this.suspended)) {
+			this.due = true;
+			return Promise.resolve();
+		}
+		if (this.running != null) return this.running;
+		const now = performance.now();
+		if (!this.due && now - this.lastPassAt < this.intervalMs) return Promise.resolve();
+		if (this.options.isActive == null) {
+			this.stopTimer();
+			this.startTimer();
+		}
+		this.due = false;
+		this.lastPassAt = now;
+		this.running = this.pass().finally(() => {
+			this.running = void 0;
+			if (this.due) this.tick();
+		});
+		return this.running;
+	}
+	/** Stats `path` once for every target that probes it in the batches in flight */
+	stat(path) {
+		if (this.batches === 0) return this.options.stat(path);
+		let stat = this.stats.get(path);
+		if (stat == null) {
+			stat = this.options.stat(path);
+			this.stats.set(path, stat);
+		}
+		return stat;
+	}
+	/** `path` changed since it was statted, so the next target to probe it in a batch in flight stats it again */
+	invalidate(path) {
+		this.stats.delete(path);
+	}
+	pass() {
+		this.stats.clear();
+		this.unread.clear();
+		return this.readAll([...this.targets]);
+	}
+	readUnread() {
+		if (this.unread.size === 0) return;
+		const targets = [...this.unread];
+		this.unread.clear();
+		this.readAll(targets);
+	}
+	async readAll(targets) {
+		this.batches++;
+		try {
+			await Promise.allSettled(targets.map((target) => this.read(target)));
+		} finally {
+			this.batches--;
+			if (this.batches === 0) this.stats.clear();
+		}
+	}
+	/** Reads `target` once any read of it in flight ends, so the reading is fresh and its probes current */
+	read(target) {
+		const poll = async () => {
+			if (!this.targets.has(target)) return;
+			await this.acquireSlot();
+			try {
+				if (this.targets.has(target)) await target.poll();
+			} finally {
+				this.releaseSlot();
+			}
+		};
+		const previous = this.reading.get(target);
+		const reading = (previous != null ? previous.then(poll, poll) : poll()).finally(() => {
+			if (this.reading.get(target) === reading) this.reading.delete(target);
+		});
+		this.reading.set(target, reading);
+		return reading;
+	}
+	acquireSlot() {
+		if (this.slotsInUse < defaultPollConcurrency) {
+			this.slotsInUse++;
+			return;
+		}
+		return new Promise((resolve) => this.waiting.push(resolve));
+	}
+	releaseSlot() {
+		const next = this.waiting.shift();
+		if (next != null) next();
+		else this.slotsInUse--;
+	}
+	startTimer() {
+		if (this.timer != null || this.disposed || this.targets.size === 0) return;
+		if (this.options.isActive != null) this.timer = setInterval(() => void this.tick(), this.activeCheckMs);
+		else if (!this.suspended) this.timer = setTimeout(() => {
+			this.timer = void 0;
+			this.due = true;
+			this.tick();
+		}, this.intervalMs);
+		else return;
+		if (typeof this.timer !== "number") this.timer.unref();
+	}
+	stopTimer() {
+		if (this.timer == null) return;
+		if (this.options.isActive != null) clearInterval(this.timer);
+		else clearTimeout(this.timer);
+		this.timer = void 0;
+		this.due = true;
+	}
+};
+/**
+* Stands in for a watcher on `basePath`: stats each probe and reports one whose `mtime:size` moved as a `change` of
+* the paths it is emitted as, through the same handler the watcher's own events take. A probe's first read (and a
+* probe new to the set, as after a branch switch) only records; one that was missing and is now present moved. A stat
+* that throws keeps the last reading, so it never counts as a move.
+*/
+var GitDirProbeTarget = class {
+	basePath;
+	stats;
+	getProbes;
+	probesByEmittedPath;
+	onMoved;
+	signatures = /* @__PURE__ */ new Map();
+	/** For each poll whose stats are in flight, the paths {@link forget} cleared meanwhile, which it must not record */
+	forgottenDuringPolls = /* @__PURE__ */ new Set();
+	constructor(basePath, stats, getProbes, probesByEmittedPath, onMoved) {
+		this.basePath = basePath;
+		this.stats = stats;
+		this.getProbes = getProbes;
+		this.probesByEmittedPath = probesByEmittedPath;
+		this.onMoved = onMoved;
+	}
+	async poll() {
+		const probes = [...this.getProbes()];
+		const forgotten = /* @__PURE__ */ new Set();
+		this.forgottenDuringPolls.add(forgotten);
+		const readings = await Promise.all(probes.map((p) => this.read(p.path)));
+		this.forgottenDuringPolls.delete(forgotten);
+		const seen = /* @__PURE__ */ new Set();
+		const moved = [];
+		for (let i = 0; i < probes.length; i++) {
+			const probe = probes[i];
+			seen.add(probe.path);
+			const reading = readings[i];
+			if (reading == null || forgotten.has(probe.path)) continue;
+			const previous = this.signatures.get(probe.path);
+			this.signatures.set(probe.path, reading);
+			if (previous != null && previous !== reading) moved.push(probe);
+		}
+		for (const path of this.signatures.keys()) if (!seen.has(path)) this.signatures.delete(path);
+		for (const probe of moved) for (const path of probe.emitAs ?? [probe.path]) this.onMoved({
+			path: joinPaths(this.basePath, path),
+			reason: "change"
+		}, probe);
+	}
+	/**
+	* The watcher reported `path` itself, so the next poll records the probes it touched (the path, a ref's lock file
+	* standing for the ref, the directories above it, and the probes emitted as it, like `logs/HEAD` as `HEAD`, which
+	* the watcher never sees) without reporting them again.
+	*/
+	forget(path) {
+		if (!isDescendant(path, this.basePath)) return;
+		let relativePath = relative(this.basePath, path);
+		if (relativePath.endsWith(".lock")) relativePath = relativePath.substring(0, relativePath.length - 5);
+		for (let p = relativePath; p.length > 0; p = p.substring(0, Math.max(0, p.lastIndexOf("/")))) this.clearSignature(p);
+		for (const probePath of this.probesByEmittedPath.get(relativePath) ?? []) this.clearSignature(probePath);
+	}
+	clearSignature(path) {
+		this.signatures.delete(path);
+		this.stats.invalidate(joinPaths(this.basePath, path));
+		for (const forgotten of this.forgottenDuringPolls) forgotten.add(path);
+	}
+	async read(path) {
+		try {
+			const stat = await this.stats.stat(joinPaths(this.basePath, path));
+			return stat == null ? "missing" : `${stat.mtime}:${stat.size}`;
+		} catch {
+			return;
+		}
+	}
+};
+//#endregion
+export { GitDirPoller, GitDirProbeTarget };
+
+//# sourceMappingURL=gitDirPoller.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gitDirPoller.js","names":[],"sources":["../../../../git/src/watching/gitDirPoller.ts"],"sourcesContent":["import type { UnifiedDisposable } from '@gitlens/utils/disposable.js';\nimport { isDescendant, joinPaths, relative } from '@gitlens/utils/path.js';\nimport type { FileWatchEvent } from './provider.js';\nimport type { WatchPollingOptions } from './watchService.js';\n\nconst defaultPollIntervalMs = 60_000;\nconst defaultPollActiveCheckMs = 5_000;\nconst defaultPollConcurrency = 4;\n\ntype GitDirStat = Awaited<ReturnType<WatchPollingOptions['stat']>>;\n\n/** Something the {@link GitDirPoller} reads once per pass */\nexport interface PollTarget {\n\tpoll(): Promise<void>;\n}\n\n/** A file or directory a poll stats, relative to the directory it watches in place of a watcher */\nexport interface GitDirProbe {\n\t/** `/`-separated, relative to the target's base path */\n\treadonly path: string;\n\t/** The relative paths a move is reported as, in place of `path` */\n\treadonly emitAs?: readonly string[];\n}\n\n/**\n * Runs passes over the poll targets of every watcher that can't be trusted, reading at most 4 targets at once across\n * passes and first readings. A target is read once soon after it is added, so its baseline doesn't wait for the next\n * pass; targets added together are read together.\n *\n * With the default gate (no `isActive`), one timer runs a pass every `intervalMs`, stopped by {@link suspend} and\n * restarted by {@link resume}, which runs a pass at once. With a host's `isActive`, whose changes core can't see, one\n * timer looks at it every `activeCheckMs`: a pass is due once `intervalMs` has gone by since the last one, or at the\n * first look after the gate opens (or after {@link nudge}), so a window that comes back between passes doesn't wait out\n * the rest of one.\n */\nexport class GitDirPoller implements UnifiedDisposable {\n\tprivate readonly targets = new Set<PollTarget>();\n\t/** Targets added since the last pass and not yet read */\n\tprivate readonly unread = new Set<PollTarget>();\n\t/** Each target's last read asked for; a target is never read twice at once, so the next waits for it */\n\tprivate readonly reading = new Map<PollTarget, Promise<void>>();\n\t/** Reads waiting for one of the {@link defaultPollConcurrency} slots, which a finished read hands over */\n\tprivate readonly waiting: (() => void)[] = [];\n\t/**\n\t * The stats of the batches (a pass, or first readings) in flight, shared by every target that probes the same path,\n\t * as the main checkout's root and its common dir do\n\t */\n\tprivate readonly stats = new Map<string, Promise<GitDirStat>>();\n\tprivate readonly intervalMs: number;\n\tprivate readonly activeCheckMs: number;\n\tprivate timer: ReturnType<typeof setTimeout> | undefined;\n\tprivate running: Promise<void> | undefined;\n\tprivate batches = 0;\n\tprivate slotsInUse = 0;\n\t/** The next look runs a pass whatever the interval says */\n\tprivate due = true;\n\tprivate lastPassAt = 0;\n\tprivate suspended = false;\n\tprivate disposed = false;\n\n\tconstructor(readonly options: WatchPollingOptions) {\n\t\tthis.intervalMs = options.intervalMs ?? defaultPollIntervalMs;\n\t\tthis.activeCheckMs = options.activeCheckMs ?? defaultPollActiveCheckMs;\n\t}\n\n\t[Symbol.dispose](): void {\n\t\tthis.dispose();\n\t}\n\n\tdispose(): void {\n\t\tthis.disposed = true;\n\t\tthis.targets.clear();\n\t\tthis.unread.clear();\n\t\tthis.stats.clear();\n\t\tthis.stopTimer();\n\t}\n\n\tget size(): number {\n\t\treturn this.targets.size;\n\t}\n\n\tadd(target: PollTarget): void {\n\t\tif (this.disposed || this.targets.has(target)) return;\n\n\t\tthis.targets.add(target);\n\t\tthis.unread.add(target);\n\t\tif (this.unread.size === 1) {\n\t\t\tqueueMicrotask(() => this.readUnread());\n\t\t}\n\t\tthis.startTimer();\n\t}\n\n\tdelete(target: PollTarget): void {\n\t\tthis.unread.delete(target);\n\t\tif (!this.targets.delete(target) || this.targets.size !== 0) return;\n\n\t\tthis.stopTimer();\n\t}\n\n\t/** Makes the next look a pass, and looks now */\n\tnudge(): void {\n\t\tthis.due = true;\n\t\tvoid this.tick();\n\t}\n\n\t/** Under the default gate, stops passes (and the timer) until {@link resume}; a host's `isActive` ignores it */\n\tsuspend(): void {\n\t\tthis.suspended = true;\n\t\tif (this.options.isActive == null) {\n\t\t\tthis.stopTimer();\n\t\t}\n\t}\n\n\t/** Lifts {@link suspend}, and runs a pass now, so what moved meanwhile is polled rather than at the next look */\n\tresume(): void {\n\t\tthis.suspended = false;\n\t\tthis.nudge();\n\t}\n\n\t/** One look at the gate: runs a pass when one is due, the gate is open and none is in flight */\n\ttick(): Promise<void> {\n\t\tif (this.disposed || this.targets.size === 0) return Promise.resolve();\n\n\t\tif (!(this.options.isActive?.() ?? !this.suspended)) {\n\t\t\tthis.due = true;\n\t\t\treturn Promise.resolve();\n\t\t}\n\n\t\t// A pass asked for while one is in flight runs once it ends; an elapsed interval just waits for the next look\n\t\tif (this.running != null) return this.running;\n\n\t\tconst now = performance.now();\n\t\tif (!this.due && now - this.lastPassAt < this.intervalMs) return Promise.resolve();\n\n\t\t// Under the default gate the timer counts the interval from this pass, whatever started it\n\t\tif (this.options.isActive == null) {\n\t\t\tthis.stopTimer();\n\t\t\tthis.startTimer();\n\t\t}\n\t\tthis.due = false;\n\t\tthis.lastPassAt = now;\n\t\tthis.running = this.pass().finally(() => {\n\t\t\tthis.running = undefined;\n\t\t\tif (this.due) {\n\t\t\t\tvoid this.tick();\n\t\t\t}\n\t\t});\n\t\treturn this.running;\n\t}\n\n\t/** Stats `path` once for every target that probes it in the batches in flight */\n\tstat(path: string): Promise<GitDirStat> {\n\t\tif (this.batches === 0) return this.options.stat(path);\n\n\t\tlet stat = this.stats.get(path);\n\t\tif (stat == null) {\n\t\t\tstat = this.options.stat(path);\n\t\t\tthis.stats.set(path, stat);\n\t\t}\n\t\treturn stat;\n\t}\n\n\t/** `path` changed since it was statted, so the next target to probe it in a batch in flight stats it again */\n\tinvalidate(path: string): void {\n\t\tthis.stats.delete(path);\n\t}\n\n\tprivate pass(): Promise<void> {\n\t\t// A pass reads its own stats, never ones from before it began\n\t\tthis.stats.clear();\n\t\t// The pass baselines any target not read yet\n\t\tthis.unread.clear();\n\t\treturn this.readAll([...this.targets]);\n\t}\n\n\tprivate readUnread(): void {\n\t\tif (this.unread.size === 0) return;\n\n\t\tconst targets = [...this.unread];\n\t\tthis.unread.clear();\n\t\tvoid this.readAll(targets);\n\t}\n\n\tprivate async readAll(targets: readonly PollTarget[]): Promise<void> {\n\t\tthis.batches++;\n\t\ttry {\n\t\t\t// A target that fails is read again next pass; nothing it saw this time is reported\n\t\t\tawait Promise.allSettled(targets.map(target => this.read(target)));\n\t\t} finally {\n\t\t\tthis.batches--;\n\t\t\tif (this.batches === 0) {\n\t\t\t\tthis.stats.clear();\n\t\t\t}\n\t\t}\n\t}\n\n\t/** Reads `target` once any read of it in flight ends, so the reading is fresh and its probes current */\n\tprivate read(target: PollTarget): Promise<void> {\n\t\tconst poll = async (): Promise<void> => {\n\t\t\tif (!this.targets.has(target)) return;\n\n\t\t\tawait this.acquireSlot();\n\t\t\ttry {\n\t\t\t\tif (this.targets.has(target)) {\n\t\t\t\t\tawait target.poll();\n\t\t\t\t}\n\t\t\t} finally {\n\t\t\t\tthis.releaseSlot();\n\t\t\t}\n\t\t};\n\t\tconst previous = this.reading.get(target);\n\t\tconst reading: Promise<void> = (previous != null ? previous.then(poll, poll) : poll()).finally(() => {\n\t\t\tif (this.reading.get(target) === reading) {\n\t\t\t\tthis.reading.delete(target);\n\t\t\t}\n\t\t});\n\t\tthis.reading.set(target, reading);\n\t\treturn reading;\n\t}\n\n\tprivate acquireSlot(): Promise<void> | undefined {\n\t\tif (this.slotsInUse < defaultPollConcurrency) {\n\t\t\tthis.slotsInUse++;\n\t\t\treturn undefined;\n\t\t}\n\n\t\treturn new Promise(resolve => this.waiting.push(resolve));\n\t}\n\n\tprivate releaseSlot(): void {\n\t\tconst next = this.waiting.shift();\n\t\tif (next != null) {\n\t\t\tnext();\n\t\t} else {\n\t\t\tthis.slotsInUse--;\n\t\t}\n\t}\n\n\tprivate startTimer(): void {\n\t\tif (this.timer != null || this.disposed || this.targets.size === 0) return;\n\n\t\tif (this.options.isActive != null) {\n\t\t\tthis.timer = setInterval(() => void this.tick(), this.activeCheckMs);\n\t\t} else if (!this.suspended) {\n\t\t\tthis.timer = setTimeout(() => {\n\t\t\t\tthis.timer = undefined;\n\t\t\t\tthis.due = true;\n\t\t\t\tvoid this.tick();\n\t\t\t}, this.intervalMs);\n\t\t} else {\n\t\t\treturn;\n\t\t}\n\n\t\t// A poll alone must not keep a (Node) process alive; in the browser timers are numbers\n\t\tif (typeof this.timer !== 'number') {\n\t\t\tthis.timer.unref();\n\t\t}\n\t}\n\n\tprivate stopTimer(): void {\n\t\tif (this.timer == null) return;\n\n\t\tif (this.options.isActive != null) {\n\t\t\tclearInterval(this.timer);\n\t\t} else {\n\t\t\tclearTimeout(this.timer);\n\t\t}\n\t\tthis.timer = undefined;\n\t\tthis.due = true;\n\t}\n}\n\n/**\n * Stands in for a watcher on `basePath`: stats each probe and reports one whose `mtime:size` moved as a `change` of\n * the paths it is emitted as, through the same handler the watcher's own events take. A probe's first read (and a\n * probe new to the set, as after a branch switch) only records; one that was missing and is now present moved. A stat\n * that throws keeps the last reading, so it never counts as a move.\n */\nexport class GitDirProbeTarget implements PollTarget {\n\tprivate readonly signatures = new Map<string, string>();\n\t/** For each poll whose stats are in flight, the paths {@link forget} cleared meanwhile, which it must not record */\n\tprivate readonly forgottenDuringPolls = new Set<Set<string>>();\n\n\tconstructor(\n\t\tprivate readonly basePath: string,\n\t\tprivate readonly stats: Pick<GitDirPoller, 'stat' | 'invalidate'>,\n\t\tprivate readonly getProbes: () => Iterable<GitDirProbe>,\n\t\t/** For each path a probe may be emitted as, the paths of the probes emitted as it */\n\t\tprivate readonly probesByEmittedPath: ReadonlyMap<string, readonly string[]>,\n\t\tprivate readonly onMoved: (event: FileWatchEvent, probe: GitDirProbe) => void,\n\t) {}\n\n\tasync poll(): Promise<void> {\n\t\tconst probes = [...this.getProbes()];\n\t\tconst forgotten = new Set<string>();\n\t\tthis.forgottenDuringPolls.add(forgotten);\n\t\tconst readings = await Promise.all(probes.map(p => this.read(p.path)));\n\t\tthis.forgottenDuringPolls.delete(forgotten);\n\n\t\tconst seen = new Set<string>();\n\t\tconst moved: GitDirProbe[] = [];\n\t\tfor (let i = 0; i < probes.length; i++) {\n\t\t\tconst probe = probes[i];\n\t\t\tseen.add(probe.path);\n\n\t\t\tconst reading = readings[i];\n\t\t\tif (reading == null || forgotten.has(probe.path)) continue;\n\n\t\t\tconst previous = this.signatures.get(probe.path);\n\t\t\tthis.signatures.set(probe.path, reading);\n\t\t\tif (previous != null && previous !== reading) {\n\t\t\t\tmoved.push(probe);\n\t\t\t}\n\t\t}\n\n\t\t// A probe that left the set starts over if it comes back\n\t\tfor (const path of this.signatures.keys()) {\n\t\t\tif (!seen.has(path)) {\n\t\t\t\tthis.signatures.delete(path);\n\t\t\t}\n\t\t}\n\n\t\tfor (const probe of moved) {\n\t\t\tfor (const path of probe.emitAs ?? [probe.path]) {\n\t\t\t\tthis.onMoved({ path: joinPaths(this.basePath, path), reason: 'change' }, probe);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * The watcher reported `path` itself, so the next poll records the probes it touched (the path, a ref's lock file\n\t * standing for the ref, the directories above it, and the probes emitted as it, like `logs/HEAD` as `HEAD`, which\n\t * the watcher never sees) without reporting them again.\n\t */\n\tforget(path: string): void {\n\t\tif (!isDescendant(path, this.basePath)) return;\n\n\t\tlet relativePath = relative(this.basePath, path);\n\t\tif (relativePath.endsWith('.lock')) {\n\t\t\trelativePath = relativePath.substring(0, relativePath.length - 5);\n\t\t}\n\n\t\tfor (let p = relativePath; p.length > 0; p = p.substring(0, Math.max(0, p.lastIndexOf('/')))) {\n\t\t\tthis.clearSignature(p);\n\t\t}\n\n\t\tfor (const probePath of this.probesByEmittedPath.get(relativePath) ?? []) {\n\t\t\tthis.clearSignature(probePath);\n\t\t}\n\t}\n\n\tprivate clearSignature(path: string): void {\n\t\tthis.signatures.delete(path);\n\t\tthis.stats.invalidate(joinPaths(this.basePath, path));\n\t\tfor (const forgotten of this.forgottenDuringPolls) {\n\t\t\tforgotten.add(path);\n\t\t}\n\t}\n\n\tprivate async read(path: string): Promise<string | undefined> {\n\t\ttry {\n\t\t\tconst stat = await this.stats.stat(joinPaths(this.basePath, path));\n\t\t\treturn stat == null ? 'missing' : `${stat.mtime}:${stat.size}`;\n\t\t} catch {\n\t\t\treturn undefined;\n\t\t}\n\t}\n}\n"],"mappings":"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"}

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

@@ -17,6 +17,15 @@ export interface FileWatchEvent {
 }
 /** Opaque token representing a filesystem watcher */
 export interface FileWatcher extends UnifiedDisposable {}
+/**
+ * How much of what changes under a watcher's `basePath` it reports:
+ * - `reliable`: everything (the state of a watcher that never reports one);
+ * - `unreliable`: what changes on this machine, but maybe not another's edits (a network volume), so core polls
+ *   beside it;
+ * - `unwatchable`: nothing (a filesystem without change notifications, or a watch that went down), so core polls
+ *   instead.
+ */
+export type FileWatcherReliability = 'reliable' | 'unreliable' | 'unwatchable';
 export interface FileWatcherOptions {
   /**
    * Directories to leave unwatched, each with everything beneath it. Entries are `/`-separated and relative to
@@ -26,6 +35,13 @@ export interface FileWatcherOptions {
    * (Map each entry to your backend's syntax — e.g. picomatch-based watchers need both `X` and `X/**`.)
    */
   readonly excludes?: readonly string[];
+  /**
+   * Reports this watcher's {@link FileWatcherReliability} whenever it changes; passed only when the host opted into
+   * polling (`WatchServiceOptions.polling`). May be called synchronously inside `createWatcher`, and again later
+   * (a watch going down, or coming back). Each watcher reports its own state, so one created on a path that is
+   * already down reports `unwatchable` itself. Going from `unwatchable` to anything else makes core rescan.
+   */
+  readonly onDidChangeReliability?: (state: FileWatcherReliability) => void;
 }
 /**
  * Factory for creating filesystem watchers. The library calls this

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

@@ -1,6 +1,7 @@
 import { UnifiedDisposable } from "../../utils/disposable.js";
-import { FileWatcher, FileWatchingProvider } from "./provider.js";
+import { FileWatcher, FileWatcherReliability, FileWatchingProvider } from "./provider.js";
 import { GitDir, RepositoryChange } from "../models/repository.js";
+import { GitDirPoller, GitDirProbeTarget } from "./gitDirPoller.js";
 //#region ../git/src/watching/watchGroup.d.ts
 /**
  * Hooks that the WatchGroup fires when events are interpreted.
@@ -9,11 +10,16 @@ import { GitDir, RepositoryChange } from "../models/repository.js";
 export interface WatchGroupHooks {
   /**
    * `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.
+   * trailing `.lock` stripped; `undefined` for any other `.git` file. `overflow` marks the every-kind rescan of a
+   * watcher that dropped events, which no single write can account for.
    */
-  readonly onRepoChanged: (repoPath: string, changes: RepositoryChange[], ref?: string) => void;
+  readonly onRepoChanged: (repoPath: string, changes: RepositoryChange[], ref?: string, overflow?: boolean) => void;
   readonly onFetchHeadChanged?: (repoPath: string) => void;
   readonly onIgnoresChanged?: (repoPath: string) => void;
+  /** The refs whose loose files a poll stats for this session, read at each poll */
+  readonly getProbeRefs?: () => Iterable<string>;
+  /** A watcher this session hears through went `unwatchable`, or stopped being it (see {@link WatchGroup.isUnwatchable}) */
+  readonly onUnwatchableChanged?: (repoPath: string) => void;
 }
 /**
  * Tracks one session's connection to a WatchGroup.
@@ -28,6 +34,9 @@ interface SessionEntry {
   /** For a linked session, its `<n>` in `<common>/worktrees/<n>`; otherwise `undefined` */
   readonly worktreeId: string | undefined;
   readonly hooks: WatchGroupHooks;
+  reliability: FileWatcherReliability;
+  /** Polls in place of (or beside) the root watcher while it isn't `reliable` */
+  target?: GitDirProbeTarget;
 }
 /**
  * Manages filesystem watchers for a single physical `.git` directory,
@@ -44,20 +53,47 @@ interface SessionEntry {
 export declare class WatchGroup implements UnifiedDisposable {
   readonly commonGitDir: string;
   private readonly provider;
+  /** When given, a watcher that reports it can't be trusted is polled; otherwise none is asked */
+  private readonly poller?;
   private readonly _sessions;
   private _commonWatcher;
+  private _commonReliability;
+  private _commonTarget;
   private _disposed;
-  constructor(commonGitDir: string, provider: FileWatchingProvider);
+  constructor(commonGitDir: string, provider: FileWatchingProvider,
+  /** When given, a watcher that reports it can't be trusted is polled; otherwise none is asked */
+  poller?: GitDirPoller | undefined);
   [Symbol.dispose](): void;
   /** Dispose the entire group (common watcher + all root watchers). */
   dispose(): void;
   get sessions(): ReadonlyMap<string, SessionEntry>;
+  /** True when a watcher the session hears through — its root watcher, or a linked session's common one — can't watch */
+  isUnwatchable(repoPath: string): boolean;
   /** Add a session to this group. Creates the root watcher for the session's gitDir. */
   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 disposeCommonWatcher;
+  /** Hosts that didn't opt into polling get exactly the options they always had */
+  private getWatcherOptions;
+  private setRootReliability;
+  private setCommonReliability;
+  private stopPolling;
+  /**
+   * A session rooted at the common dir polls the common files too, with the refs of every session in the group: its
+   * combined watcher would hear them all. While the common dir is polled too, the poller stats each shared file once
+   * for both, and each keeps its own readings, so what one watcher reported is held back from its own sessions only
+   */
+  private getRootProbes;
+  /**
+   * A linked worktree's `logs/HEAD` moved — a commit or reset there, on a branch a polled session rooted at the common
+   * dir may not probe — so each such session hears a `heads` change its combined watcher would have heard
+   */
+  private onLinkedHeadMoved;
+  /** The common files, with the refs of every linked session (the only ones the common watcher delivers to) */
+  private getCommonProbes;
   private onCommonEvent;
   private deliverOverflow;
   private onRootEvent;

package/dist/git/watching/watchGroup.js

@@ -1,6 +1,7 @@
 import { some } from "../../utils/iterable.js";
 import { isDescendant, relative } from "../../utils/path.js";
-import { dotGitGlobCombined, dotGitGlobCommon, dotGitGlobRoot, gitDirExcludes, shouldIgnoreRepoPath } from "./watcherPatterns.js";
+import { GitDirProbeTarget } from "./gitDirPoller.js";
+import { dotGitGlobCombined, dotGitGlobCommon, dotGitGlobRoot, getGitDirRefProbes, gitDirCommonProbes, gitDirExcludes, gitDirProbesByEmittedPath, gitDirRootProbes, shouldIgnoreRepoPath } from "./watcherPatterns.js";
 import { allWatchedRepositoryChanges, classifyGitDirChange } from "./classifyChange.js";
 //#region ../git/src/watching/watchGroup.ts
 /**
@@ -18,12 +19,16 @@ import { allWatchedRepositoryChanges, classifyGitDirChange } from "./classifyCha
 var WatchGroup = class {
 	commonGitDir;
 	provider;
+	poller;
 	_sessions = /* @__PURE__ */ new Map();
 	_commonWatcher;
+	_commonReliability = "reliable";
+	_commonTarget;
 	_disposed = false;
-	constructor(commonGitDir, provider) {
+	constructor(commonGitDir, provider, poller) {
 		this.commonGitDir = commonGitDir;
 		this.provider = provider;
+		this.poller = poller;
 	}
 	[Symbol.dispose]() {
 		this.dispose();
@@ -32,34 +37,52 @@ var WatchGroup = class {
 	dispose() {
 		if (this._disposed) return;
 		this._disposed = true;
-		for (const entry of this._sessions.values()) entry.rootWatcher.dispose();
+		for (const entry of this._sessions.values()) {
+			entry.rootWatcher.dispose();
+			this.stopPolling(entry);
+		}
 		this._sessions.clear();
-		this._commonWatcher?.dispose();
-		this._commonWatcher = void 0;
+		this.disposeCommonWatcher();
 	}
 	get sessions() {
 		return this._sessions;
 	}
+	/** True when a watcher the session hears through — its root watcher, or a linked session's common one — can't watch */
+	isUnwatchable(repoPath) {
+		const entry = this._sessions.get(repoPath);
+		if (entry == null) return false;
+		return entry.reliability === "unwatchable" || !entry.coversCommon && this._commonReliability === "unwatchable";
+	}
 	/** Add a session to this group. Creates the root watcher for the session's gitDir. */
 	addSession(repoPath, gitDir, hooks) {
 		if (this._disposed) return;
 		if (this._sessions.has(repoPath)) return;
 		const isStandard = gitDir.commonUri == null;
 		const rootPattern = isStandard ? dotGitGlobCombined : dotGitGlobRoot;
+		let entry;
+		let initialReliability = "reliable";
 		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 e = this._sessions.get(repoPath);
+			if (e != null) {
+				if (event.reason !== "overflow") e.target?.forget(event.path);
+				this.onRootEvent(event, e);
+			}
+		}, this.getWatcherOptions((state) => {
+			if (entry == null) initialReliability = state;
+			else if (this._sessions.get(repoPath) === entry) this.setRootReliability(entry, state);
+		}));
 		const entryGitDirPath = gitDir.uri.fsPath;
-		const entry = {
+		entry = {
 			repoPath,
 			gitDirPath: entryGitDirPath,
 			rootWatcher,
 			coversCommon: isStandard,
 			worktreeId: isStandard ? void 0 : this.getWorktreeId(entryGitDirPath),
-			hooks
+			hooks,
+			reliability: "reliable"
 		};
 		this._sessions.set(repoPath, entry);
+		if (initialReliability !== "reliable") this.setRootReliability(entry, initialReliability, true);
 		if (!isStandard) this.ensureCommonWatcher();
 	}
 	/** Remove a session from this group. Disposes its root watcher. */
@@ -67,11 +90,9 @@ var WatchGroup = class {
 		const entry = this._sessions.get(repoPath);
 		if (entry == null) return;
 		entry.rootWatcher.dispose();
+		this.stopPolling(entry);
 		this._sessions.delete(repoPath);
-		if (this._commonWatcher != null && !some(this._sessions.values(), (e) => !e.coversCommon)) {
-			this._commonWatcher.dispose();
-			this._commonWatcher = void 0;
-		}
+		if (this._commonWatcher != null && !some(this._sessions.values(), (e) => !e.coversCommon)) this.disposeCommonWatcher();
 	}
 	getWorktreeId(gitDirPath) {
 		if (!isDescendant(gitDirPath, this.commonGitDir)) return void 0;
@@ -82,9 +103,114 @@ var WatchGroup = class {
 	}
 	ensureCommonWatcher() {
 		if (this._commonWatcher != null || this._disposed) return;
-		this._commonWatcher = this.provider.createWatcher(this.commonGitDir, dotGitGlobCommon, (event) => {
+		let watcher;
+		let initialReliability = "reliable";
+		const options = this.getWatcherOptions((state) => {
+			if (watcher == null) initialReliability = state;
+			else if (this._commonWatcher === watcher) this.setCommonReliability(state);
+		});
+		watcher = this.provider.createWatcher(this.commonGitDir, dotGitGlobCommon, (event) => {
+			if (event.reason !== "overflow") this._commonTarget?.forget(event.path);
 			this.onCommonEvent(event);
-		}, { excludes: gitDirExcludes });
+		}, options);
+		this._commonWatcher = watcher;
+		if (initialReliability !== "reliable") this.setCommonReliability(initialReliability, true);
+	}
+	disposeCommonWatcher() {
+		this._commonWatcher?.dispose();
+		this._commonWatcher = void 0;
+		this._commonReliability = "reliable";
+		if (this._commonTarget != null) {
+			this.poller?.delete(this._commonTarget);
+			this._commonTarget = void 0;
+		}
+	}
+	/** Hosts that didn't opt into polling get exactly the options they always had */
+	getWatcherOptions(onDidChangeReliability) {
+		return this.poller != null ? {
+			excludes: gitDirExcludes,
+			onDidChangeReliability
+		} : { excludes: gitDirExcludes };
+	}
+	setRootReliability(entry, state, initial) {
+		const previous = entry.reliability;
+		if (previous === state || this.poller == null) return;
+		entry.reliability = state;
+		if (state === "reliable") this.stopPolling(entry);
+		else if (entry.target == null) {
+			const target = new GitDirProbeTarget(entry.gitDirPath, this.poller, () => this.getRootProbes(entry), gitDirProbesByEmittedPath, (event, probe) => {
+				if (entry.target !== target) return;
+				this.onRootEvent(event, entry);
+				if (probe.path === "logs/HEAD" && !entry.coversCommon) this.onLinkedHeadMoved();
+			});
+			entry.target = target;
+			this.poller.add(target);
+		}
+		if (state === "unwatchable" === (previous === "unwatchable")) return;
+		if (!initial) this.deliverOverflow(entry);
+		entry.hooks.onUnwatchableChanged?.(entry.repoPath);
+	}
+	setCommonReliability(state, initial) {
+		const previous = this._commonReliability;
+		if (previous === state || this.poller == null) return;
+		this._commonReliability = state;
+		if (state === "reliable") {
+			if (this._commonTarget != null) {
+				this.poller.delete(this._commonTarget);
+				this._commonTarget = void 0;
+			}
+		} else if (this._commonTarget == null) {
+			const target = new GitDirProbeTarget(this.commonGitDir, this.poller, () => this.getCommonProbes(), gitDirProbesByEmittedPath, (event) => {
+				if (this._commonTarget === target) this.onCommonEvent(event);
+			});
+			this._commonTarget = target;
+			this.poller.add(target);
+		}
+		if (state === "unwatchable" === (previous === "unwatchable")) return;
+		for (const entry of this._sessions.values()) {
+			if (entry.coversCommon) continue;
+			if (!initial) this.deliverOverflow(entry);
+			entry.hooks.onUnwatchableChanged?.(entry.repoPath);
+		}
+	}
+	stopPolling(entry) {
+		if (entry.target == null) return;
+		this.poller?.delete(entry.target);
+		entry.target = void 0;
+	}
+	/**
+	* A session rooted at the common dir polls the common files too, with the refs of every session in the group: its
+	* combined watcher would hear them all. While the common dir is polled too, the poller stats each shared file once
+	* for both, and each keeps its own readings, so what one watcher reported is held back from its own sessions only
+	*/
+	getRootProbes(entry) {
+		if (!entry.coversCommon) return gitDirRootProbes;
+		const refs = /* @__PURE__ */ new Set();
+		for (const e of this._sessions.values()) for (const ref of e.hooks.getProbeRefs?.() ?? []) refs.add(ref);
+		return [
+			...gitDirRootProbes,
+			...gitDirCommonProbes,
+			...getGitDirRefProbes(refs)
+		];
+	}
+	/**
+	* A linked worktree's `logs/HEAD` moved — a commit or reset there, on a branch a polled session rooted at the common
+	* dir may not probe — so each such session hears a `heads` change its combined watcher would have heard
+	*/
+	onLinkedHeadMoved() {
+		for (const entry of this._sessions.values()) {
+			if (!entry.coversCommon || entry.target == null) continue;
+			entry.hooks.onRepoChanged(entry.repoPath, ["heads"]);
+		}
+	}
+	/** The common files, with the refs of every linked session (the only ones the common watcher delivers to) */
+	getCommonProbes() {
+		const refs = /* @__PURE__ */ new Set();
+		for (const entry of this._sessions.values()) {
+			if (entry.coversCommon) continue;
+			for (const ref of entry.hooks.getProbeRefs?.() ?? []) refs.add(ref);
+		}
+		return [...gitDirCommonProbes, ...getGitDirRefProbes(refs)];
 	}
 	onCommonEvent(event) {
 		if (event.reason === "overflow") {
@@ -118,7 +244,7 @@ var WatchGroup = class {
 		}
 	}
 	deliverOverflow(entry) {
-		entry.hooks.onRepoChanged(entry.repoPath, [...allWatchedRepositoryChanges]);
+		entry.hooks.onRepoChanged(entry.repoPath, [...allWatchedRepositoryChanges], void 0, true);
 		entry.hooks.onFetchHeadChanged?.(entry.repoPath);
 		entry.hooks.onIgnoresChanged?.(entry.repoPath);
 	}