@gitkraken/core-gitlens 0.12.0 → 0.13.0

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

@@ -27,12 +27,23 @@ export declare class WatcherRepoChangeEvent {
   protected readonly _changes: Set<RepositoryChange>;
   private readonly _refs;
   private readonly _unnamedRefKinds;
+  private readonly _announced;
   constructor(
   /** The repository path this event is for */
   repoPath: string, changes: RepositoryChange[],
   /** Which refs changed; when omitted, every ref kind in `changes` is unnamed (any ref of that kind may have moved) */
-  refs?: WatcherRefChanges);
+  refs?: WatcherRefChanges,
+  /** The kinds of `changes` that come only from core's own announced writes (see {@link announced}) */
+  announced?: Iterable<RepositoryChange>);
   get changes(): ReadonlySet<RepositoryChange>;
+  /**
+   * The kinds in {@link changes} that come only from core's own writes, which core already announced through
+   * `hooks.repository.onChanged` after evicting their caches. A host that handled that announcement can skip them;
+   * a kind the watcher or an injected change also reported is not among them.
+   */
+  get announced(): ReadonlySet<RepositoryChange>;
+  /** The kinds in {@link changes} that aren't {@link announced}: what a cache that core already evicted for its write still has to clear */
+  getUnannouncedChanges(): RepositoryChange[];
   /** Full ref names (or ref directories, or pseudo-refs) known to have changed. See {@link WatcherRefChanges.names}. */
   get refs(): ReadonlySet<string>;
   /** Ref kinds that changed without a name — any ref of these kinds may have moved */
@@ -66,7 +77,7 @@ export declare class WatcherRepoChangeEvent {
   changedExclusive(...affected: RepositoryChange[]): boolean;
   /**
    * Coalesce: return a new event with all changes and refs from both this and the given set. When `refs` is omitted,
-   * every ref kind in `changes` counts as unnamed.
+   * every ref kind in `changes` counts as unnamed. A kind in `changes` is no longer {@link announced}.
    */
   with(changes: RepositoryChange[], refs?: WatcherRefChanges): WatcherRepoChangeEvent;
 }

package/dist/git/watching/changeEvent.js

@@ -26,7 +26,8 @@ var WatcherRepoChangeEvent = class WatcherRepoChangeEvent {
 	_changes;
 	_refs;
 	_unnamedRefKinds;
-	constructor(repoPath, changes, refs) {
+	_announced;
+	constructor(repoPath, changes, refs, announced) {
 		this.repoPath = repoPath;
 		this._changes = new Set(changes);
 		if (refs == null) {
@@ -36,10 +37,23 @@ var WatcherRepoChangeEvent = class WatcherRepoChangeEvent {
 			this._refs = new Set(refs.names);
 			this._unnamedRefKinds = new Set(refs.unnamed);
 		}
+		this._announced = announced != null ? new Set(filter(announced, (c) => this._changes.has(c))) : /* @__PURE__ */ new Set();
 	}
 	get changes() {
 		return this._changes;
 	}
+	/**
+	* The kinds in {@link changes} that come only from core's own writes, which core already announced through
+	* `hooks.repository.onChanged` after evicting their caches. A host that handled that announcement can skip them;
+	* a kind the watcher or an injected change also reported is not among them.
+	*/
+	get announced() {
+		return this._announced;
+	}
+	/** The kinds in {@link changes} that aren't {@link announced}: what a cache that core already evicted for its write still has to clear */
+	getUnannouncedChanges() {
+		return this._announced.size ? [...filter(this._changes, (c) => !this._announced.has(c))] : [...this._changes];
+	}
 	/** Full ref names (or ref directories, or pseudo-refs) known to have changed. See {@link WatcherRefChanges.names}. */
 	get refs() {
 		return this._refs;
@@ -101,7 +115,7 @@ var WatcherRepoChangeEvent = class WatcherRepoChangeEvent {
 	}
 	/**
 	* Coalesce: return a new event with all changes and refs from both this and the given set. When `refs` is omitted,
-	* every ref kind in `changes` counts as unnamed.
+	* every ref kind in `changes` counts as unnamed. A kind in `changes` is no longer {@link announced}.
 	*/
 	with(changes, refs) {
 		const names = [...this._refs];
@@ -114,7 +128,7 @@ var WatcherRepoChangeEvent = class WatcherRepoChangeEvent {
 		return new WatcherRepoChangeEvent(this.repoPath, [...this._changes, ...changes], {
 			names,
 			unnamed
-		});
+		}, filter(this._announced, (c) => !changes.includes(c)));
 	}
 };
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"changeEvent.js","names":[],"sources":["../../../../git/src/watching/changeEvent.ts"],"sourcesContent":["import { filter, some } from '@gitlens/utils/iterable.js';\nimport type { RepositoryChange } from '../models/repository.js';\n\n/** The {@link RepositoryChange} kinds that describe ref movement, which an event can attribute to named refs */\nexport type RefChangeKind = 'heads' | 'remotes' | 'tags' | 'stash';\n\nexport interface WatcherRefChanges {\n\t/** Full ref names whose files changed (`refs/heads/main`), plus per-worktree pseudo-refs (`HEAD`, `ORIG_HEAD`). A name may be a ref directory and then covers every ref beneath it. */\n\treadonly names?: Iterable<string>;\n\t/** Ref kinds that changed without a name (packed-refs rewrite, config, shallow/replace, an injected change): any ref of that kind may have moved. */\n\treadonly unnamed?: Iterable<RefChangeKind>;\n}\n\nexport function isRefChangeKind(change: RepositoryChange): change is RefChangeKind {\n\treturn change === 'heads' || change === 'remotes' || change === 'tags' || change === 'stash';\n}\n\n/**\n * The kind of ref a full ref name (or ref directory) belongs to. A pseudo-ref (no `refs/` prefix, e.g. `HEAD`,\n * `ORIG_HEAD`) counts as `heads`; a ref outside the watched namespaces (e.g. `refs/notes/x`) has no kind.\n */\nexport function getRefChangeKind(ref: string): RefChangeKind | undefined {\n\tif (!ref.startsWith('refs/')) return 'heads';\n\tif (ref.startsWith('refs/heads/')) return 'heads';\n\tif (ref.startsWith('refs/remotes/')) return 'remotes';\n\tif (ref.startsWith('refs/tags/')) return 'tags';\n\tif (ref === 'refs/stash') return 'stash';\n\n\treturn undefined;\n}\n\n/**\n * An event describing changes to a repository, produced by the watching pipeline.\n *\n * Changes are coalesced within a debounce window — a single event may represent\n * multiple filesystem changes. Use {@link changed} to test for specific change types,\n * and {@link mayHaveChangedRef} to test whether a specific ref may have moved.\n */\nexport class WatcherRepoChangeEvent {\n\tprotected readonly _changes: Set<RepositoryChange>;\n\tprivate readonly _refs: Set<string>;\n\tprivate readonly _unnamedRefKinds: Set<RefChangeKind>;\n\n\tconstructor(\n\t\t/** The repository path this event is for */\n\t\tpublic readonly repoPath: string,\n\t\tchanges: RepositoryChange[],\n\t\t/** Which refs changed; when omitted, every ref kind in `changes` is unnamed (any ref of that kind may have moved) */\n\t\trefs?: WatcherRefChanges,\n\t) {\n\t\tthis._changes = new Set(changes);\n\t\tif (refs == null) {\n\t\t\tthis._refs = new Set();\n\t\t\tthis._unnamedRefKinds = new Set(filter(changes, isRefChangeKind));\n\t\t} else {\n\t\t\tthis._refs = new Set(refs.names);\n\t\t\tthis._unnamedRefKinds = new Set(refs.unnamed);\n\t\t}\n\t}\n\n\tget changes(): ReadonlySet<RepositoryChange> {\n\t\treturn this._changes;\n\t}\n\n\t/** Full ref names (or ref directories, or pseudo-refs) known to have changed. See {@link WatcherRefChanges.names}. */\n\tget refs(): ReadonlySet<string> {\n\t\treturn this._refs;\n\t}\n\n\t/** Ref kinds that changed without a name — any ref of these kinds may have moved */\n\tget unnamedRefKinds(): ReadonlySet<RefChangeKind> {\n\t\treturn this._unnamedRefKinds;\n\t}\n\n\ttoString(changesOnly: boolean = false): string {\n\t\tconst changeList = [...this._changes].join(', ');\n\t\tconst refCount = this._refs.size;\n\t\tif (changesOnly) return refCount ? `changes=${changeList}, refs=${refCount}` : `changes=${changeList}`;\n\n\t\treturn refCount\n\t\t\t? `{ repoPath: ${this.repoPath}, changes: ${changeList}, refs: ${refCount} }`\n\t\t\t: `{ repoPath: ${this.repoPath}, changes: ${changeList} }`;\n\t}\n\n\t/**\n\t * Test whether the given ref may have moved in this event.\n\t *\n\t * @param ref - A full ref name (`refs/heads/main`) or a pseudo-ref (`HEAD`).\n\t * @returns `false` when the ref's kind didn't change (or the ref is outside the watched kinds); `true` when its kind\n\t *   changed without a name, or when the ref itself or a ref directory above it changed. `HEAD` is usually a symref\n\t *   to the checked-out branch, so it may have moved whenever any `heads` ref did.\n\t */\n\tmayHaveChangedRef(ref: string): boolean {\n\t\tconst kind = getRefChangeKind(ref);\n\t\tif (kind == null || !this._changes.has(kind)) return false;\n\t\tif (this._unnamedRefKinds.has(kind) || ref === 'HEAD') return true;\n\n\t\treturn findCoveringRefName(this._refs, ref) != null;\n\t}\n\n\t/**\n\t * Test whether any of the specified change types are present in the event.\n\t *\n\t * @param affected - Change types to test for.\n\t * @returns `true` if any of the specified changes are present.\n\t */\n\tchanged(...affected: RepositoryChange[]): boolean {\n\t\treturn some(this._changes, c => affected.includes(c));\n\t}\n\n\t/**\n\t * Test whether the event contains ONLY the specified change types.\n\t *\n\t * `pausedOp` is treated as a union of `cherryPick`, `merge`, `rebase`,\n\t * and `revert` for convenience.\n\t *\n\t * @param affected - Change types to test for.\n\t * @returns `true` if the event contains only the specified changes.\n\t */\n\tchangedExclusive(...affected: RepositoryChange[]): boolean {\n\t\tlet changes = this._changes;\n\n\t\t// When checking for specific paused operation types, also accept the union type\n\t\tif (\n\t\t\taffected.includes('cherryPick') ||\n\t\t\taffected.includes('merge') ||\n\t\t\taffected.includes('rebase') ||\n\t\t\taffected.includes('revert')\n\t\t) {\n\t\t\tif (!affected.includes('pausedOp')) {\n\t\t\t\taffected = [...affected, 'pausedOp'];\n\t\t\t}\n\t\t} else if (affected.includes('pausedOp')) {\n\t\t\t// When checking for the union type exclusively, ignore specific subtypes\n\t\t\tchanges = new Set(changes);\n\t\t\tchanges.delete('cherryPick');\n\t\t\tchanges.delete('merge');\n\t\t\tchanges.delete('rebase');\n\t\t\tchanges.delete('revert');\n\t\t}\n\n\t\tconst intersection = [...filter(changes, c => affected.includes(c))];\n\t\treturn intersection.length === changes.size;\n\t}\n\n\t/**\n\t * Coalesce: return a new event with all changes and refs from both this and the given set. When `refs` is omitted,\n\t * every ref kind in `changes` counts as unnamed.\n\t */\n\twith(changes: RepositoryChange[], refs?: WatcherRefChanges): WatcherRepoChangeEvent {\n\t\tconst names = [...this._refs];\n\t\tconst unnamed = [...this._unnamedRefKinds];\n\t\tif (refs == null) {\n\t\t\tunnamed.push(...filter(changes, isRefChangeKind));\n\t\t} else {\n\t\t\tif (refs.names != null) {\n\t\t\t\tnames.push(...refs.names);\n\t\t\t}\n\t\t\tif (refs.unnamed != null) {\n\t\t\t\tunnamed.push(...refs.unnamed);\n\t\t\t}\n\t\t}\n\n\t\treturn new WatcherRepoChangeEvent(this.repoPath, [...this._changes, ...changes], {\n\t\t\tnames: names,\n\t\t\tunnamed: unnamed,\n\t\t});\n\t}\n}\n\n/**\n * Returns the name in `names` that covers `ref` — `ref` itself, or a ref directory above it (compared on `/`\n * boundaries, so `refs/heads/fe` doesn't cover `refs/heads/feature`) — or `undefined` if none does.\n */\nexport function findCoveringRefName(names: ReadonlySet<string>, ref: string): string | undefined {\n\tif (names.size === 0) return undefined;\n\tif (names.has(ref)) return ref;\n\n\tlet index = ref.lastIndexOf('/');\n\twhile (index > 0) {\n\t\tconst dir = ref.substring(0, index);\n\t\tif (names.has(dir)) return dir;\n\n\t\tindex = ref.lastIndexOf('/', index - 1);\n\t}\n\treturn undefined;\n}\n\n/**\n * An event describing working tree file changes, produced by the working tree pipeline.\n *\n * Paths have already been filtered through the gitignore filter and noise filter.\n */\nexport interface WorkingTreeChangeEvent {\n\treadonly repoPath: string;\n\t/**\n\t * Absolute paths of changed files or directories (post-gitignore filtering). A directory stands for everything\n\t * beneath it. Partial when {@link incomplete}.\n\t */\n\treadonly paths: ReadonlySet<string>;\n\t/**\n\t * `true` when more paths changed than the accumulator retains, so {@link paths} is a partial set and a\n\t * miss does NOT mean the file is unchanged. Consumers testing membership must treat this as a match.\n\t */\n\treadonly incomplete: boolean;\n}\n"],"mappings":"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"}
+{"version":3,"file":"changeEvent.js","names":[],"sources":["../../../../git/src/watching/changeEvent.ts"],"sourcesContent":["import { filter, some } from '@gitlens/utils/iterable.js';\nimport type { RepositoryChange } from '../models/repository.js';\n\n/** The {@link RepositoryChange} kinds that describe ref movement, which an event can attribute to named refs */\nexport type RefChangeKind = 'heads' | 'remotes' | 'tags' | 'stash';\n\nexport interface WatcherRefChanges {\n\t/** Full ref names whose files changed (`refs/heads/main`), plus per-worktree pseudo-refs (`HEAD`, `ORIG_HEAD`). A name may be a ref directory and then covers every ref beneath it. */\n\treadonly names?: Iterable<string>;\n\t/** Ref kinds that changed without a name (packed-refs rewrite, config, shallow/replace, an injected change): any ref of that kind may have moved. */\n\treadonly unnamed?: Iterable<RefChangeKind>;\n}\n\nexport function isRefChangeKind(change: RepositoryChange): change is RefChangeKind {\n\treturn change === 'heads' || change === 'remotes' || change === 'tags' || change === 'stash';\n}\n\n/**\n * The kind of ref a full ref name (or ref directory) belongs to. A pseudo-ref (no `refs/` prefix, e.g. `HEAD`,\n * `ORIG_HEAD`) counts as `heads`; a ref outside the watched namespaces (e.g. `refs/notes/x`) has no kind.\n */\nexport function getRefChangeKind(ref: string): RefChangeKind | undefined {\n\tif (!ref.startsWith('refs/')) return 'heads';\n\tif (ref.startsWith('refs/heads/')) return 'heads';\n\tif (ref.startsWith('refs/remotes/')) return 'remotes';\n\tif (ref.startsWith('refs/tags/')) return 'tags';\n\tif (ref === 'refs/stash') return 'stash';\n\n\treturn undefined;\n}\n\n/**\n * An event describing changes to a repository, produced by the watching pipeline.\n *\n * Changes are coalesced within a debounce window — a single event may represent\n * multiple filesystem changes. Use {@link changed} to test for specific change types,\n * and {@link mayHaveChangedRef} to test whether a specific ref may have moved.\n */\nexport class WatcherRepoChangeEvent {\n\tprotected readonly _changes: Set<RepositoryChange>;\n\tprivate readonly _refs: Set<string>;\n\tprivate readonly _unnamedRefKinds: Set<RefChangeKind>;\n\tprivate readonly _announced: Set<RepositoryChange>;\n\n\tconstructor(\n\t\t/** The repository path this event is for */\n\t\tpublic readonly repoPath: string,\n\t\tchanges: RepositoryChange[],\n\t\t/** Which refs changed; when omitted, every ref kind in `changes` is unnamed (any ref of that kind may have moved) */\n\t\trefs?: WatcherRefChanges,\n\t\t/** The kinds of `changes` that come only from core's own announced writes (see {@link announced}) */\n\t\tannounced?: Iterable<RepositoryChange>,\n\t) {\n\t\tthis._changes = new Set(changes);\n\t\tif (refs == null) {\n\t\t\tthis._refs = new Set();\n\t\t\tthis._unnamedRefKinds = new Set(filter(changes, isRefChangeKind));\n\t\t} else {\n\t\t\tthis._refs = new Set(refs.names);\n\t\t\tthis._unnamedRefKinds = new Set(refs.unnamed);\n\t\t}\n\t\tthis._announced = announced != null ? new Set(filter(announced, c => this._changes.has(c))) : new Set();\n\t}\n\n\tget changes(): ReadonlySet<RepositoryChange> {\n\t\treturn this._changes;\n\t}\n\n\t/**\n\t * The kinds in {@link changes} that come only from core's own writes, which core already announced through\n\t * `hooks.repository.onChanged` after evicting their caches. A host that handled that announcement can skip them;\n\t * a kind the watcher or an injected change also reported is not among them.\n\t */\n\tget announced(): ReadonlySet<RepositoryChange> {\n\t\treturn this._announced;\n\t}\n\n\t/** The kinds in {@link changes} that aren't {@link announced}: what a cache that core already evicted for its write still has to clear */\n\tgetUnannouncedChanges(): RepositoryChange[] {\n\t\treturn this._announced.size ? [...filter(this._changes, c => !this._announced.has(c))] : [...this._changes];\n\t}\n\n\t/** Full ref names (or ref directories, or pseudo-refs) known to have changed. See {@link WatcherRefChanges.names}. */\n\tget refs(): ReadonlySet<string> {\n\t\treturn this._refs;\n\t}\n\n\t/** Ref kinds that changed without a name — any ref of these kinds may have moved */\n\tget unnamedRefKinds(): ReadonlySet<RefChangeKind> {\n\t\treturn this._unnamedRefKinds;\n\t}\n\n\ttoString(changesOnly: boolean = false): string {\n\t\tconst changeList = [...this._changes].join(', ');\n\t\tconst refCount = this._refs.size;\n\t\tif (changesOnly) return refCount ? `changes=${changeList}, refs=${refCount}` : `changes=${changeList}`;\n\n\t\treturn refCount\n\t\t\t? `{ repoPath: ${this.repoPath}, changes: ${changeList}, refs: ${refCount} }`\n\t\t\t: `{ repoPath: ${this.repoPath}, changes: ${changeList} }`;\n\t}\n\n\t/**\n\t * Test whether the given ref may have moved in this event.\n\t *\n\t * @param ref - A full ref name (`refs/heads/main`) or a pseudo-ref (`HEAD`).\n\t * @returns `false` when the ref's kind didn't change (or the ref is outside the watched kinds); `true` when its kind\n\t *   changed without a name, or when the ref itself or a ref directory above it changed. `HEAD` is usually a symref\n\t *   to the checked-out branch, so it may have moved whenever any `heads` ref did.\n\t */\n\tmayHaveChangedRef(ref: string): boolean {\n\t\tconst kind = getRefChangeKind(ref);\n\t\tif (kind == null || !this._changes.has(kind)) return false;\n\t\tif (this._unnamedRefKinds.has(kind) || ref === 'HEAD') return true;\n\n\t\treturn findCoveringRefName(this._refs, ref) != null;\n\t}\n\n\t/**\n\t * Test whether any of the specified change types are present in the event.\n\t *\n\t * @param affected - Change types to test for.\n\t * @returns `true` if any of the specified changes are present.\n\t */\n\tchanged(...affected: RepositoryChange[]): boolean {\n\t\treturn some(this._changes, c => affected.includes(c));\n\t}\n\n\t/**\n\t * Test whether the event contains ONLY the specified change types.\n\t *\n\t * `pausedOp` is treated as a union of `cherryPick`, `merge`, `rebase`,\n\t * and `revert` for convenience.\n\t *\n\t * @param affected - Change types to test for.\n\t * @returns `true` if the event contains only the specified changes.\n\t */\n\tchangedExclusive(...affected: RepositoryChange[]): boolean {\n\t\tlet changes = this._changes;\n\n\t\t// When checking for specific paused operation types, also accept the union type\n\t\tif (\n\t\t\taffected.includes('cherryPick') ||\n\t\t\taffected.includes('merge') ||\n\t\t\taffected.includes('rebase') ||\n\t\t\taffected.includes('revert')\n\t\t) {\n\t\t\tif (!affected.includes('pausedOp')) {\n\t\t\t\taffected = [...affected, 'pausedOp'];\n\t\t\t}\n\t\t} else if (affected.includes('pausedOp')) {\n\t\t\t// When checking for the union type exclusively, ignore specific subtypes\n\t\t\tchanges = new Set(changes);\n\t\t\tchanges.delete('cherryPick');\n\t\t\tchanges.delete('merge');\n\t\t\tchanges.delete('rebase');\n\t\t\tchanges.delete('revert');\n\t\t}\n\n\t\tconst intersection = [...filter(changes, c => affected.includes(c))];\n\t\treturn intersection.length === changes.size;\n\t}\n\n\t/**\n\t * Coalesce: return a new event with all changes and refs from both this and the given set. When `refs` is omitted,\n\t * every ref kind in `changes` counts as unnamed. A kind in `changes` is no longer {@link announced}.\n\t */\n\twith(changes: RepositoryChange[], refs?: WatcherRefChanges): WatcherRepoChangeEvent {\n\t\tconst names = [...this._refs];\n\t\tconst unnamed = [...this._unnamedRefKinds];\n\t\tif (refs == null) {\n\t\t\tunnamed.push(...filter(changes, isRefChangeKind));\n\t\t} else {\n\t\t\tif (refs.names != null) {\n\t\t\t\tnames.push(...refs.names);\n\t\t\t}\n\t\t\tif (refs.unnamed != null) {\n\t\t\t\tunnamed.push(...refs.unnamed);\n\t\t\t}\n\t\t}\n\n\t\treturn new WatcherRepoChangeEvent(\n\t\t\tthis.repoPath,\n\t\t\t[...this._changes, ...changes],\n\t\t\t{ names: names, unnamed: unnamed },\n\t\t\tfilter(this._announced, c => !changes.includes(c)),\n\t\t);\n\t}\n}\n\n/**\n * Returns the name in `names` that covers `ref` — `ref` itself, or a ref directory above it (compared on `/`\n * boundaries, so `refs/heads/fe` doesn't cover `refs/heads/feature`) — or `undefined` if none does.\n */\nexport function findCoveringRefName(names: ReadonlySet<string>, ref: string): string | undefined {\n\tif (names.size === 0) return undefined;\n\tif (names.has(ref)) return ref;\n\n\tlet index = ref.lastIndexOf('/');\n\twhile (index > 0) {\n\t\tconst dir = ref.substring(0, index);\n\t\tif (names.has(dir)) return dir;\n\n\t\tindex = ref.lastIndexOf('/', index - 1);\n\t}\n\treturn undefined;\n}\n\n/**\n * An event describing working tree file changes, produced by the working tree pipeline.\n *\n * Paths have already been filtered through the gitignore filter and noise filter.\n */\nexport interface WorkingTreeChangeEvent {\n\treadonly repoPath: string;\n\t/**\n\t * Absolute paths of changed files or directories (post-gitignore filtering). A directory stands for everything\n\t * beneath it. Partial when {@link incomplete}.\n\t */\n\treadonly paths: ReadonlySet<string>;\n\t/**\n\t * `true` when more paths changed than the accumulator retains, so {@link paths} is a partial set and a\n\t * miss does NOT mean the file is unchanged. Consumers testing membership must treat this as a match.\n\t */\n\treadonly incomplete: boolean;\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,111 @@
+import { UnifiedDisposable } from "../../utils/disposable.js";
+import { FileWatchEvent } from "./provider.js";
+import { WatchPollingOptions } from "./watchService.js";
+//#region ../git/src/watching/gitDirPoller.d.ts
+type GitDirStat = Awaited<ReturnType<WatchPollingOptions['stat']>>;
+/** Something the {@link GitDirPoller} reads once per pass */
+export interface PollTarget {
+  poll(): Promise<void>;
+}
+/** A file or directory a poll stats, relative to the directory it watches in place of a watcher */
+export interface GitDirProbe {
+  /** `/`-separated, relative to the target's base path */
+  readonly path: string;
+  /** The relative paths a move is reported as, in place of `path` */
+  readonly emitAs?: readonly string[];
+}
+/**
+ * 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.
+ */
+export declare class GitDirPoller implements UnifiedDisposable {
+  readonly options: WatchPollingOptions;
+  private readonly targets;
+  /** Targets added since the last pass and not yet read */
+  private readonly unread;
+  /** Each target's last read asked for; a target is never read twice at once, so the next waits for it */
+  private readonly reading;
+  /** Reads waiting for one of the {@link defaultPollConcurrency} slots, which a finished read hands over */
+  private readonly 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
+   */
+  private readonly stats;
+  private readonly intervalMs;
+  private readonly activeCheckMs;
+  private timer;
+  private running;
+  private batches;
+  private slotsInUse;
+  /** The next look runs a pass whatever the interval says */
+  private due;
+  private lastPassAt;
+  private suspended;
+  private disposed;
+  constructor(options: WatchPollingOptions);
+  [Symbol.dispose](): void;
+  dispose(): void;
+  get size(): number;
+  add(target: PollTarget): void;
+  delete(target: PollTarget): void;
+  /** Makes the next look a pass, and looks now */
+  nudge(): void;
+  /** Under the default gate, stops passes (and the timer) until {@link resume}; a host's `isActive` ignores it */
+  suspend(): void;
+  /** Lifts {@link suspend}, and runs a pass now, so what moved meanwhile is polled rather than at the next look */
+  resume(): void;
+  /** One look at the gate: runs a pass when one is due, the gate is open and none is in flight */
+  tick(): Promise<void>;
+  /** Stats `path` once for every target that probes it in the batches in flight */
+  stat(path: string): Promise<GitDirStat>;
+  /** `path` changed since it was statted, so the next target to probe it in a batch in flight stats it again */
+  invalidate(path: string): void;
+  private pass;
+  private readUnread;
+  private readAll;
+  /** Reads `target` once any read of it in flight ends, so the reading is fresh and its probes current */
+  private read;
+  private acquireSlot;
+  private releaseSlot;
+  private startTimer;
+  private stopTimer;
+}
+/**
+ * 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.
+ */
+export declare class GitDirProbeTarget implements PollTarget {
+  private readonly basePath;
+  private readonly stats;
+  private readonly getProbes;
+  /** For each path a probe may be emitted as, the paths of the probes emitted as it */
+  private readonly probesByEmittedPath;
+  private readonly onMoved;
+  private readonly signatures;
+  /** For each poll whose stats are in flight, the paths {@link forget} cleared meanwhile, which it must not record */
+  private readonly forgottenDuringPolls;
+  constructor(basePath: string, stats: Pick<GitDirPoller, 'stat' | 'invalidate'>, getProbes: () => Iterable<GitDirProbe>,
+  /** For each path a probe may be emitted as, the paths of the probes emitted as it */
+  probesByEmittedPath: ReadonlyMap<string, readonly string[]>, onMoved: (event: FileWatchEvent, probe: GitDirProbe) => void);
+  poll(): Promise<void>;
+  /**
+   * 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: string): void;
+  private clearSignature;
+  private read;
+}
+//#endregion
+//# sourceMappingURL=gitDirPoller.d.ts.map

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