@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/src/plus/integrations/utils/integration.utils.ts

@@ -1,215 +0,0 @@
-import type { RemoteProvider, RemoteProviderId } from '../../../git/models/remoteProvider.js';
-import type { CloudGitSelfManagedHostIntegrationIds, IntegrationIds } from '../constants.js';
-import {
-	GitCloudHostIntegrationId,
-	GitSelfManagedHostIntegrationId,
-	IssuesCloudHostIntegrationId,
-} from '../constants.js';
-import type { GitHostIntegration } from '../models/gitHostIntegration.js';
-import type { Integration, IntegrationConnectedKey } from '../models/integration.js';
-// These domain checks come from `providers/models.ts` (already imported here) rather than the individual
-// provider modules: those read `providersMetadata[...]` synchronously at module init, so importing from them
-// while `providers/models.ts` is still loading triggers a TDZ on `providersMetadata`. Importing the shared
-// predicates keeps one definition of each regex — duplicating them let a fix land in only one place.
-import { isAzureCloudDomain, isBitbucketCloudDomain, isGitHubDotCom, isGitLabDotCom } from '../providers/models.js';
-
-const selfHostedIntegrationIds: GitSelfManagedHostIntegrationId[] = [
-	GitSelfManagedHostIntegrationId.CloudGitHubEnterprise,
-	GitSelfManagedHostIntegrationId.CloudGitLabSelfHosted,
-	GitSelfManagedHostIntegrationId.BitbucketServer,
-	GitSelfManagedHostIntegrationId.AzureDevOpsServer,
-] as const;
-
-export const supportedIntegrationIds: IntegrationIds[] = [
-	GitCloudHostIntegrationId.GitHub,
-	GitCloudHostIntegrationId.GitLab,
-	GitCloudHostIntegrationId.Bitbucket,
-	GitCloudHostIntegrationId.AzureDevOps,
-	IssuesCloudHostIntegrationId.Jira,
-	IssuesCloudHostIntegrationId.Trello,
-	...selfHostedIntegrationIds,
-] as const;
-
-export function convertRemoteProviderIdToIntegrationId(
-	remoteProviderId: RemoteProviderId,
-): GitCloudHostIntegrationId | GitSelfManagedHostIntegrationId | undefined {
-	switch (remoteProviderId) {
-		case 'azure-devops':
-			return GitCloudHostIntegrationId.AzureDevOps;
-		case 'bitbucket':
-			return GitCloudHostIntegrationId.Bitbucket;
-		case 'github':
-			return GitCloudHostIntegrationId.GitHub;
-		case 'gitlab':
-			return GitCloudHostIntegrationId.GitLab;
-		case 'bitbucket-server':
-			return GitSelfManagedHostIntegrationId.BitbucketServer;
-		default:
-			return undefined;
-	}
-}
-
-export function getIntegrationConnectedKey<T extends IntegrationIds>(
-	id: T,
-	domain?: string,
-): IntegrationConnectedKey<T> {
-	if (isGitSelfManagedHostIntegrationId(id)) {
-		if (!domain) {
-			throw new Error(`Domain is required for self-managed integration ID: ${id}`);
-		}
-		return `connected:${id}:${domain}` as IntegrationConnectedKey<T>;
-	}
-
-	return `connected:${id}` as IntegrationConnectedKey<T>;
-}
-
-export function getIntegrationIdForRemote(
-	provider: RemoteProvider | undefined,
-): GitCloudHostIntegrationId | GitSelfManagedHostIntegrationId | undefined {
-	switch (provider?.id) {
-		case 'azure-devops':
-			if (isAzureCloudDomain(provider.domain)) {
-				return GitCloudHostIntegrationId.AzureDevOps;
-			}
-			return provider.custom ? undefined : GitSelfManagedHostIntegrationId.AzureDevOpsServer;
-		case 'bitbucket':
-		case 'bitbucket-server':
-			if (isBitbucketCloudDomain(provider.domain)) {
-				return GitCloudHostIntegrationId.Bitbucket;
-			}
-			return GitSelfManagedHostIntegrationId.BitbucketServer;
-		case 'github':
-			if (provider.domain != null && !isGitHubDotCom(provider.domain)) {
-				return GitSelfManagedHostIntegrationId.CloudGitHubEnterprise;
-			}
-			return GitCloudHostIntegrationId.GitHub;
-		case 'gitlab':
-			if (provider.domain != null && !isGitLabDotCom(provider.domain)) {
-				return GitSelfManagedHostIntegrationId.CloudGitLabSelfHosted;
-			}
-			return GitCloudHostIntegrationId.GitLab;
-		default:
-			return undefined;
-	}
-}
-
-export function isCloudGitSelfManagedHostIntegrationId(
-	id: IntegrationIds,
-): id is CloudGitSelfManagedHostIntegrationIds {
-	switch (id) {
-		case GitSelfManagedHostIntegrationId.CloudGitHubEnterprise:
-		case GitSelfManagedHostIntegrationId.CloudGitLabSelfHosted:
-		case GitSelfManagedHostIntegrationId.BitbucketServer:
-		case GitSelfManagedHostIntegrationId.AzureDevOpsServer:
-			return true;
-		default:
-			return false;
-	}
-}
-
-/**
- * Whether a provider's cloud token uses `expiresIn: 0` to mean "never expires" (rather than "already
- * expired"). GitHub and the cloud self-managed hosts always return 0 for their non-expiring tokens; Trello
- * is issued with `expiration: never` (identity-service), so its cloud token comes back as 0 too. Callers
- * must map 0 → a far-future expiry for these, or the session is immediately treated as expired.
- */
-export function isNonExpiringZeroTokenIntegrationId(id: IntegrationIds): boolean {
-	return (
-		id === GitCloudHostIntegrationId.GitHub ||
-		id === IssuesCloudHostIntegrationId.Trello ||
-		isCloudGitSelfManagedHostIntegrationId(id)
-	);
-}
-
-export function isGitHostIntegration(integration: Integration): integration is GitHostIntegration {
-	return integration.type === 'git';
-}
-
-export function isGitCloudHostIntegrationId(id: IntegrationIds): id is GitCloudHostIntegrationId {
-	switch (id) {
-		case GitCloudHostIntegrationId.GitHub:
-		case GitCloudHostIntegrationId.GitLab:
-		case GitCloudHostIntegrationId.Bitbucket:
-		case GitCloudHostIntegrationId.AzureDevOps:
-			return true;
-		default:
-			return false;
-	}
-}
-
-export function isGitSelfManagedHostIntegrationId(id: IntegrationIds): id is GitSelfManagedHostIntegrationId {
-	return selfHostedIntegrationIds.includes(id as GitSelfManagedHostIntegrationId);
-}
-
-/**
- * Whether this id belongs to a dedicated issue tracker (resource → project) rather than a git host.
- *
- * Decided from the id alone, so a read can refuse a mismatched surface — a repo/PR read asked of Jira, or an
- * issue-tracker project read asked of GitHub — before resolving a connection. The instance-level
- * {@link isIssuesIntegration} answers the same question once an integration is in hand.
- */
-export function isIssuesHostIntegrationId(id: IntegrationIds): id is IssuesCloudHostIntegrationId {
-	switch (id) {
-		case IssuesCloudHostIntegrationId.Jira:
-		case IssuesCloudHostIntegrationId.Linear:
-		case IssuesCloudHostIntegrationId.Trello:
-			return true;
-		default:
-			return false;
-	}
-}
-
-/**
- * Whether a read targeted only by an explicit self-managed `domain` (no `connectionId`) must treat a
- * session-less core result as a broken target instead of an empty account. Without this, a self-managed host
- * addressed only by domain — the manual-token/external-auth case `domain` exists to cover — returns an empty
- * success with no warning and no `fetchFailed`, indistinguishable from "this host has nothing".
- */
-export function warnOnMissingSessionForDomain(id: IntegrationIds, domain: string | undefined): boolean {
-	return domain != null && isGitSelfManagedHostIntegrationId(id);
-}
-
-/** Maps an integration id to the git-remote provider type used by the remote-URL matcher. */
-export function remoteProviderTypeForIntegration(id: IntegrationIds): RemoteProviderId | undefined {
-	switch (id) {
-		case GitCloudHostIntegrationId.GitHub:
-		case GitSelfManagedHostIntegrationId.CloudGitHubEnterprise:
-			return 'github';
-		case GitCloudHostIntegrationId.GitLab:
-		case GitSelfManagedHostIntegrationId.CloudGitLabSelfHosted:
-			return 'gitlab';
-		case GitCloudHostIntegrationId.Bitbucket:
-			return 'bitbucket';
-		case GitSelfManagedHostIntegrationId.BitbucketServer:
-			return 'bitbucket-server';
-		case GitCloudHostIntegrationId.AzureDevOps:
-		case GitSelfManagedHostIntegrationId.AzureDevOpsServer:
-			return 'azure-devops';
-		default:
-			return undefined;
-	}
-}
-
-/** Normalizes a host remote-config `type` string (e.g. `'GitHub'`) to a git-remote provider type. */
-export function remoteProviderTypeForConfig(type: string): RemoteProviderId | undefined {
-	switch (type.toLowerCase()) {
-		case 'github':
-			return 'github';
-		case 'gitlab':
-			return 'gitlab';
-		case 'bitbucket':
-			return 'bitbucket';
-		case 'bitbucket-server':
-		case 'bitbucketserver':
-			return 'bitbucket-server';
-		case 'azuredevops':
-		case 'azure-devops':
-			return 'azure-devops';
-		case 'gitea':
-			return 'gitea';
-		case 'gerrit':
-			return 'gerrit';
-		default:
-			return undefined;
-	}
-}

package/src/utils/array.ts

@@ -1,194 +0,0 @@
-import { join } from './iterable.js';
-
-export function areEqual<T>(a: readonly T[] | undefined, b: readonly T[] | undefined): boolean {
-	if (a === b) return true;
-	if (a == null || b == null) return false;
-	if (a.length !== b.length) return false;
-	return a.every((value, index) => value === b[index]);
-}
-
-export function chunk<T>(source: T[], size: number): T[][] {
-	const chunks = [];
-
-	let index = 0;
-	while (index < source.length) {
-		chunks.push(source.slice(index, size + index));
-		index += size;
-	}
-	return chunks;
-}
-
-export function countStringLength(source: string[]): number {
-	let length = 0;
-	for (const s of source) {
-		length += s.length;
-	}
-	return length;
-}
-
-export function countUniques<T>(source: T[], accessor: (item: T) => string): Record<string, number> {
-	const uniqueCounts = Object.create(null) as Record<string, number>;
-	for (const item of source) {
-		const value = accessor(item);
-		uniqueCounts[value] = (uniqueCounts[value] ?? 0) + 1;
-	}
-	return uniqueCounts;
-}
-
-export function ensureArray<T>(source: NonNullable<T> | NonNullable<T>[]): T[];
-export function ensureArray<T>(source: NonNullable<T> | NonNullable<T>[] | undefined): NonNullable<T>[] | undefined;
-export function ensureArray<T>(source: NonNullable<T> | NonNullable<T>[] | undefined): NonNullable<T>[] | undefined {
-	return source == null ? undefined : Array.isArray(source) ? source : [source];
-}
-
-export function exhaustiveArray<T>() {
-	return <const A extends readonly T[]>(
-		...args: [T] extends [A[number]] ? [array: A] : [{ missingMembers: Exclude<T, A[number]> }]
-	): A => args[0] as A;
-}
-
-export function filterMap<T, TMapped>(
-	source: readonly T[],
-	predicateMapper: (item: T, index: number) => TMapped | null | undefined,
-): TMapped[] {
-	let index = 0;
-	return source.reduce<TMapped[]>((accumulator, current) => {
-		const mapped = predicateMapper(current, index++);
-		if (mapped != null) {
-			accumulator.push(mapped);
-		}
-		return accumulator;
-	}, []);
-}
-
-export function findLastIndex<T>(source: T[], predicate: (value: T, index: number, obj: T[]) => boolean): number {
-	let l = source.length;
-	while (l--) {
-		if (predicate(source[l], l, source)) return l;
-	}
-	return -1;
-}
-
-export function intersection<T>(sources: T[][], comparator: (a: T, b: T) => boolean): T[] {
-	const results: T[] = [];
-
-	const length = sources.length;
-	outer: for (const item of sources[0]) {
-		let i = length - 1;
-		while (i--) {
-			if (!sources[i + 1].some(v => comparator(v, item))) break outer;
-		}
-
-		if (!results.some(v => comparator(v, item))) {
-			results.push(item);
-		}
-	}
-
-	return results;
-}
-
-export function isStringArray<T extends any[]>(array: readonly string[] | T): array is string[] {
-	return typeof array[0] === 'string';
-}
-
-export interface HierarchicalItem<T> {
-	name: string;
-	relativePath: string;
-	value?: T;
-
-	parent?: HierarchicalItem<T>;
-	children: Map<string, HierarchicalItem<T>> | undefined;
-	descendants: T[] | undefined;
-}
-
-export function makeHierarchical<T>(
-	values: T[],
-	splitPath: (i: T) => string[],
-	joinPath: (...paths: string[]) => string,
-	compact: boolean = false,
-	canCompact?: (i: T) => boolean,
-): HierarchicalItem<T> {
-	const seed = { name: '', relativePath: '', children: new Map(), descendants: [] };
-
-	let hierarchy = values.reduce((root: HierarchicalItem<T>, value) => {
-		let folder = root;
-
-		let relativePath = '';
-		for (const folderName of splitPath(value)) {
-			relativePath = joinPath(relativePath, folderName);
-
-			folder.children ??= new Map();
-			let f = folder.children.get(folderName);
-			if (f == null) {
-				f = {
-					name: folderName,
-					relativePath: relativePath,
-					parent: folder,
-					children: undefined,
-					descendants: undefined,
-				};
-				folder.children.set(folderName, f);
-			}
-
-			folder.descendants ??= [];
-			folder.descendants.push(value);
-			folder = f;
-		}
-
-		folder.value = value;
-
-		return root;
-	}, seed);
-
-	if (compact) {
-		hierarchy = compactHierarchy(hierarchy, joinPath, true, canCompact);
-	}
-
-	return hierarchy;
-}
-
-export function compactHierarchy<T>(
-	root: HierarchicalItem<T>,
-	joinPath: (...paths: string[]) => string,
-	isRoot: boolean = true,
-	canCompact?: (i: T) => boolean,
-): HierarchicalItem<T> {
-	if (root.children == null) return root;
-
-	const children = [...root.children.values()];
-	for (const child of children) {
-		compactHierarchy(child, joinPath, false, canCompact);
-	}
-
-	if (!isRoot && root.value == null && children.length === 1) {
-		const child = children[0];
-		if (child.value == null || canCompact?.(child.value)) {
-			root.name = joinPath(root.name, child.name);
-			root.relativePath = child.relativePath;
-			root.children = child.children;
-			root.descendants = child.descendants;
-			root.value = child.value;
-
-			// Update the parent pointer for the new children if they exist
-			if (root.children != null) {
-				for (const grandChild of root.children.values()) {
-					grandChild.parent = root;
-				}
-			}
-		}
-	}
-
-	return root;
-}
-
-export function unique<T>(source: readonly T[]): T[] {
-	return [...new Set(source)];
-}
-
-export function joinUnique<T>(source: readonly T[], separator: string): string {
-	return join(new Set(source), separator);
-}
-
-export function splitAt<T>(source: T[], index: number): [T[], T[]] {
-	return index < 0 ? [source, []] : [source.slice(0, index), source.slice(index)];
-}

package/src/utils/base64.ts

@@ -1 +0,0 @@
-export { base64, fromBase64, fromBase64ToString } from '#env/base64.js';

package/src/utils/brand.ts

@@ -1,7 +0,0 @@
-declare const __brand: unique symbol;
-declare const __base: unique symbol;
-
-type _Brand<Base, B> = { [__brand]: B; [__base]: Base };
-export type Branded<Base, B> = Base & _Brand<Base, B>;
-export type Brand<B extends Branded<any, any>> = B extends Branded<any, any> ? B : never;
-export type Unbrand<T> = T extends _Brand<infer Base, any> ? Base : never;

package/src/utils/cancellation.ts

@@ -1,199 +0,0 @@
-import { getScopedCounter } from './counter.js';
-
-const cancellationErrorBrand = Symbol.for('CancellationError');
-
-/**
- * A standalone CancellationError for use in the library.
- * Uses a symbol brand so that both this class and the extension's
- * CancellationError (which extends vscode.CancellationError) are
- * recognized by `isCancellationError`.
- */
-export class CancellationError extends Error {
-	readonly [cancellationErrorBrand] = true;
-
-	constructor(public readonly original?: Error) {
-		super();
-		this.name = 'CancellationError';
-
-		if (this.original) {
-			if (this.original.message.startsWith('Operation cancelled')) {
-				this.message = this.original.message;
-			} else {
-				this.message = `Operation cancelled; ${this.original.message}`;
-			}
-		} else {
-			this.message = 'Operation cancelled';
-		}
-		Error.captureStackTrace?.(this, new.target);
-	}
-}
-
-export function isCancellationError(ex: unknown): ex is CancellationError {
-	return (
-		(ex instanceof Error && (cancellationErrorBrand in ex || ex.name === 'CancellationError')) ||
-		(ex instanceof DOMException && ex.name === 'AbortError')
-	);
-}
-
-/**
- * Races a promise against an `AbortSignal`. If the signal fires before
- * the promise settles, the returned promise rejects with `CancellationError`.
- * If the promise settles first, the signal listener is cleaned up.
- */
-export function raceWithSignal<T>(promise: Promise<T>, signal: AbortSignal): Promise<T> {
-	if (signal.aborted) return Promise.reject(new CancellationError());
-
-	return new Promise<T>((resolve, reject) => {
-		const onAbort = () => reject(new CancellationError());
-		signal.addEventListener('abort', onAbort, { once: true });
-		promise.then(
-			v => {
-				signal.removeEventListener('abort', onAbort);
-				resolve(v);
-			},
-			(e: unknown) => {
-				signal.removeEventListener('abort', onAbort);
-				reject(e instanceof Error ? e : new Error(String(e)));
-			},
-		);
-	});
-}
-
-/**
- * Races a promise against a timeout. If `ms` elapses before the promise settles, the returned promise
- * rejects with `CancellationError`. If the promise settles first, the timer is cleared. Parallels
- * `raceWithSignal`, with a timer standing in for the signal.
- *
- * When `abortOnTimeout` is provided, it is aborted on timeout — so a caller can link the underlying operation to
- * it (e.g. via `AbortSignal.any`) and have it torn down instead of orphaned. Abort is best-effort (a truly-stuck
- * op may ignore it); the returned promise rejects on timeout regardless of whether the underlying op settles.
- */
-export function raceWithTimeout<T>(promise: Promise<T>, ms: number, abortOnTimeout?: AbortController): Promise<T> {
-	return new Promise<T>((resolve, reject) => {
-		const timer = setTimeout(() => {
-			const error = new CancellationError(new Error(`Timed out after ${ms}ms`));
-			abortOnTimeout?.abort(error);
-			reject(error);
-		}, ms);
-		// Don't let the timeout timer keep a (Node) process alive on its own — a still-pending promise shouldn't
-		// hold the event loop open just for its backstop (no-op in the browser, where setTimeout returns a number).
-		if (typeof timer !== 'number') {
-			timer.unref();
-		}
-		promise.then(
-			v => {
-				clearTimeout(timer);
-				resolve(v);
-			},
-			(e: unknown) => {
-				clearTimeout(timer);
-				reject(e instanceof Error ? e : new Error(String(e)));
-			},
-		);
-	});
-}
-
-/**
- * Aggregates multiple caller `AbortSignal`s into a single signal that
- * only fires when **all** callers have cancelled (the inverse of `AbortSignal.any()`).
- *
- * Designed for shared-promise caching: each caller registers their signal,
- * and the underlying operation receives the aggregate signal. Individual callers
- * can cancel early (via `raceWithSignal`), but the operation continues as long
- * as at least one caller is still active.
- */
-export class AbortAggregate {
-	private readonly controller = new AbortController();
-	private activeCount = 0;
-	/** One listener-remover per registration (NOT keyed by signal), so adding the same signal twice is safe. */
-	private readonly cleanups = new Set<() => void>();
-
-	/** The aggregate signal — only fires when all callers have cancelled. */
-	get signal(): AbortSignal {
-		return this.controller.signal;
-	}
-
-	/**
-	 * Register a caller.
-	 * - If `cancellation` is provided, the caller is auto-removed when it fires.
-	 * - If `cancellation` is `undefined`, the caller is "permanent" — the aggregate
-	 *   can never fire while it's active. Call the returned cleanup on promise settle.
-	 * - The same signal instance may safely be added more than once — each registration is tracked and cleaned up
-	 *   independently, so no listener leaks.
-	 * @returns A cleanup function to unregister the caller.
-	 */
-	add(cancellation?: AbortSignal): () => void {
-		this.activeCount++;
-
-		if (cancellation == null) {
-			return () => {
-				this.activeCount--;
-				this.checkAbort();
-			};
-		}
-
-		if (cancellation.aborted) {
-			this.activeCount--;
-			this.checkAbort();
-			return () => {};
-		}
-
-		// Track this registration's listener removal individually (a Set of removers, NOT keyed by the signal) so
-		// adding the same signal twice can't overwrite the other's cleanup. `settled` keeps both exit paths (abort
-		// vs. manual cleanup) idempotent and preserves the accounting: only `onAbort` decrements `activeCount`.
-		let settled = false;
-		let remove: () => void;
-		const onAbort = () => {
-			if (settled) return;
-
-			settled = true;
-			this.cleanups.delete(remove);
-			this.activeCount--;
-			this.checkAbort();
-		};
-		remove = () => cancellation.removeEventListener('abort', onAbort);
-		cancellation.addEventListener('abort', onAbort, { once: true });
-		this.cleanups.add(remove);
-
-		return () => {
-			if (settled) return;
-
-			settled = true;
-			this.cleanups.delete(remove);
-			remove();
-		};
-	}
-
-	private checkAbort(): void {
-		if (this.activeCount <= 0 && !this.controller.signal.aborted) {
-			this.controller.abort();
-		}
-	}
-
-	/** Remove all abort listeners. Call when the cached promise settles. */
-	dispose(): void {
-		for (const remove of this.cleanups) {
-			remove();
-		}
-		this.cleanups.clear();
-	}
-}
-
-const signalIds = new WeakMap<AbortSignal, number>();
-const signalIdCounter = getScopedCounter();
-
-/**
- * Returns a stable, unique numeric ID for the given AbortSignal.
- * Used to differentiate concurrent git commands that have different
- * cancellation signals, so one caller aborting doesn't cancel another.
- */
-export function getAbortSignalId(signal: AbortSignal | undefined): string {
-	if (signal == null) return '';
-
-	let id = signalIds.get(signal);
-	if (id == null) {
-		id = signalIdCounter.next();
-		signalIds.set(signal, id);
-	}
-	return String(id);
-}

package/src/utils/charCode.ts

@@ -1,38 +0,0 @@
-export const CharCode = {
-	/**
-	 * The `#` character.
-	 */
-	Hash: 35,
-	/**
-	 * The `/` character.
-	 */
-	Slash: 47,
-	Digit0: 48,
-	Digit1: 49,
-	Digit2: 50,
-	Digit3: 51,
-	Digit4: 52,
-	Digit5: 53,
-	Digit6: 54,
-	Digit7: 55,
-	Digit8: 56,
-	Digit9: 57,
-	/**
-	 * The `\` character.
-	 */
-	Backslash: 92,
-	A: 65,
-	B: 66,
-	C: 67,
-	D: 68,
-	E: 69,
-	F: 70,
-	Z: 90,
-	a: 97,
-	b: 98,
-	c: 99,
-	d: 100,
-	e: 101,
-	f: 102,
-	z: 122,
-} as const satisfies Record<string, number>;

package/src/utils/coalescedRun.ts

@@ -1,45 +0,0 @@
-/** Single-flight async runner with one trailing rerun: `run()` while a run is in flight joins the
- *  SAME promise and marks it dirty; when the run settles (resolve OR reject), one trailing `refire`
- *  fires so state that changed mid-run is re-processed. `refire` should re-enter the owner's calling
- *  method (which applies its own gates) — fire-and-forget. `markDirty()` forces the trailing refire
- *  (e.g. on a repo swap mid-run) without joining. */
-export class CoalescedRun<T> {
-	private _dirty = false;
-	private _inflight: Promise<T> | undefined;
-
-	constructor(
-		private readonly fn: () => Promise<T>,
-		private readonly refire: () => void,
-	) {}
-
-	get running(): boolean {
-		return this._inflight != null;
-	}
-
-	markDirty(): void {
-		if (this._inflight != null) {
-			this._dirty = true;
-		}
-	}
-
-	run(): Promise<T> {
-		if (this._inflight != null) {
-			this._dirty = true;
-			return this._inflight;
-		}
-
-		// Defer `fn` to a microtask so `_inflight` is assigned BEFORE any of fn's code runs — a
-		// synchronous reentrant `run()` from fn's prologue then joins instead of double-running.
-		const promise = Promise.resolve()
-			.then(this.fn)
-			.finally(() => {
-				this._inflight = undefined;
-				if (this._dirty) {
-					this._dirty = false;
-					this.refire();
-				}
-			});
-		this._inflight = promise;
-		return promise;
-	}
-}