@gitkraken/core-gitlens 0.5.116 → 0.7.0

package/src/plus/integrations/reads/pullRequests.ts

@@ -1,260 +0,0 @@
-import type { PullRequestShape, PullRequestStateFilter } from '../../../git/models/pullRequest.js';
-import { mergeAssessmentInto } from '../collectionMetadata.js';
-import type { IntegrationIds } from '../constants.js';
-import type { ProviderPullRequest, ProviderReposInput, PullRequestFilter } from '../providers/models.js';
-import { fromProviderPullRequest, PagingMode, providersMetadata } from '../providers/models.js';
-import type { ProviderPagedResult } from '../results.js';
-import { reconcileOmissionsWithFailure } from '../results.js';
-import {
-	isGitHostIntegration,
-	isIssuesHostIntegrationId,
-	warnOnMissingSessionForDomain,
-} from '../utils/integration.utils.js';
-import type { ProviderReadContext } from './context.js';
-import { getCurrentAccountId, runCaptured } from './drains.js';
-import { resolveAccountWidePullRequestFilters, resolvePullRequestFilters } from './filters.js';
-import {
-	drainToRequestedPage,
-	isPageNumberAdvanceable,
-	pageToCursor,
-	refusedPage,
-	resolveContinuation,
-	resolveCurrentPage,
-	toProviderPageInfo,
-} from './paging.js';
-import {
-	gitHostOnlySurfaceWarning,
-	truncationWarning,
-	unsupportedAccountWidePullRequestFiltersWarning,
-	unsupportedFiltersWarning,
-} from './warnings.js';
-
-export async function listPullRequestsPage(
-	ctx: ProviderReadContext,
-	options: {
-		providerId: IntegrationIds;
-		repos?: ProviderReposInput;
-		states?: PullRequestStateFilter[];
-		/**
-		 * PR relationship filters (e.g. `[Author, Assignee, ReviewRequested]`). On repo-scoped reads members
-		 * combine as provider query constraints (normally an intersection); on account-wide reads they form an
-		 * exact OR union. The whole set is validated against the selected path's capability.
-		 */
-		filters?: PullRequestFilter[];
-		/**
-		 * Account-wide only: include review-requested PRs when the provider's native "my PRs" query omits them.
-		 * This extends the provider-native result; it is not a narrowing filter.
-		 */
-		includeReviewRequested?: boolean;
-		page?: number;
-		cursor?: string;
-		/**
-		 * Requests the lightweight row shape (see {@link IntegrationManager.listPullRequestsPage}). Opt-in
-		 * only, and only on the repo-scoped branch: the account-wide branch has always read the lightweight
-		 * shape and keeps doing so, so an explicit `false` does not widen it back to the full projection.
-		 */
-		summary?: boolean;
-		itemsPerPage?: number;
-		forceSync?: boolean;
-		connectionId?: string;
-		/**
-		 * Explicit self-managed host domain when no configured connection supplies one. The value must come
-		 * from the trusted authentication configuration, not repository or remote data.
-		 */
-		domain?: string;
-	},
-): Promise<ProviderPagedResult<PullRequestShape>> {
-	// Truncated as well as floored, like every other paged read here: `page` is reported back as
-	// `page.currentPage` and compared against the position a drain reached, and neither can be fractional.
-	const page = Math.max(1, Math.trunc(options.page ?? 1));
-	if (isIssuesHostIntegrationId(options.providerId)) {
-		return refusedPage(
-			page,
-			[gitHostOnlySurfaceWarning(options.providerId, undefined, options.connectionId, 'pull request reads')],
-			true,
-		);
-	}
-
-	const integration = await ctx.getIntegrationForRead(options.providerId, options.connectionId, options.domain);
-	if (integration == null) {
-		// A supplied connection or domain that no longer resolves is a broken target, not an empty account —
-		// surface a no-connection warning + fetchFailed rather than a silent empty page.
-		const early = ctx.earlyReturnConnectionWarnings(options.providerId, options.connectionId, options.domain);
-		return refusedPage(page, early.warnings, early.fetchFailed);
-	}
-	if (!isGitHostIntegration(integration)) {
-		return refusedPage(
-			page,
-			[gitHostOnlySurfaceWarning(options.providerId, undefined, options.connectionId, 'pull request reads')],
-			true,
-		);
-	}
-
-	await ctx.forceRefreshIfRequested(integration, options.forceSync, options.connectionId);
-
-	const domain = ctx.domainForRead(integration, options.providerId, options.connectionId, options.domain);
-	// With no repos this is an account-wide "my PRs" read; the repo-scoped core rejects an empty `repos`
-	// input, so route to the account-wide, inherently user-scoped core instead (see drainPullRequests).
-	// That provider-defined path takes no `pageSize`. A page-only request is handled by walking any opaque
-	// continuations it supplies below. Do NOT synthesize a page-number cursor for it: cursor-based queries
-	// (e.g. GitHub `involves:`) ignore a page number and would return their first page.
-	const accountWide = (options.repos?.length ?? 0) === 0;
-	const cursor = accountWide ? options.cursor : (options.cursor ?? pageToCursor(page));
-
-	const resolvedFilters = accountWide
-		? resolveAccountWidePullRequestFilters(options.providerId, options.filters)
-		: resolvePullRequestFilters(options.providerId, options.filters);
-	if (resolvedFilters.unsupported) {
-		return refusedPage(
-			page,
-			[
-				accountWide
-					? unsupportedAccountWidePullRequestFiltersWarning(
-							options.providerId,
-							domain,
-							options.connectionId,
-							options.filters ?? [],
-						)
-					: unsupportedFiltersWarning(options.providerId, domain, options.connectionId),
-			],
-			true,
-		);
-	}
-
-	// Everything but the cursor, shared by the initial read and the drain's re-reads below so the two cannot
-	// drift. `summary` is the reason this matters beyond tidiness: a re-read that dropped it would both
-	// revert to the full payload — on the very path that issues the most requests — and return rows of a
-	// different shape than the first page, since a summary row reports `headCommit`/`commitCount` as absent.
-	// `summary` is pinned true here rather than forwarded: this branch has never had a full projection to
-	// fall back to (see the option's doc), so honoring an explicit `false` would promise a widening the read
-	// cannot deliver.
-	const accountWideInput = {
-		state: options.states,
-		includeReviewRequested: options.includeReviewRequested ?? false,
-		filters: resolvedFilters.filters,
-		summary: true,
-	};
-	// `filters` scopes the read to the current user (the core resolves the account for these), so it returns
-	// the user's PRs. `pageSize` rides along so PagingMode.Repo hosts (GitLab, Bitbucket, Azure), whose
-	// per-repo cursor path ignores a synthesized page-number cursor, honor the requested size.
-	const scopedInput = {
-		state: options.states,
-		filters: resolvedFilters.filters,
-		pageSize: options.itemsPerPage,
-		summary: options.summary,
-	};
-	const readPage = (pageCursor: string | undefined, requestedPage?: number) =>
-		runCaptured(
-			options.providerId,
-			domain,
-			options.connectionId,
-			() =>
-				accountWide
-					? integration.getMyPullRequestsForUserResult(
-							{ ...accountWideInput, cursor: pageCursor },
-							options.connectionId,
-						)
-					: integration.getMyPullRequestsForReposResult(
-							options.repos ?? [],
-							{ ...scopedInput, cursor: pageCursor, page: requestedPage },
-							options.connectionId,
-						),
-			{
-				warnOnMissingSession: warnOnMissingSessionForDomain(options.providerId, options.domain),
-			},
-		);
-	const { value, warning } = await readPage(cursor, options.page != null ? page : undefined);
-
-	let items = value?.values ?? [];
-	// Cursor-only account-wide reads start at page 1; a page-only request is advanced through opaque
-	// continuations below. Repo-scoped reads report the requested page unless the provider reports its own.
-	let paged = toProviderPageInfo(items.length, value?.paging);
-	let allMetadata = value?.metadata;
-	// Convert the SDK collection metadata into scope-aware warnings + failure/truncation flags, appending
-	// them to any captured thrown-error warning without discarding the partial result's items.
-	const warnings = warning != null ? [warning] : [];
-	let pageFetchFailed = warning != null && value == null;
-
-	// Cursor-only reads ignore a synthesized page-number cursor, so a page-only request is advanced through
-	// the provider's own continuations (see drainToRequestedPage).
-	if (
-		(accountWide || providersMetadata[options.providerId]?.pullRequestsPagingMode === PagingMode.Repos) &&
-		options.page != null &&
-		page > 1 &&
-		options.cursor == null &&
-		paged.page.currentPage === 1
-	) {
-		const drained = await drainToRequestedPage<ProviderPullRequest>(
-			{ items: items, paged: paged, metadata: allMetadata, fetchFailed: pageFetchFailed },
-			{
-				requestedPage: page,
-				itemsPerPage: options.itemsPerPage,
-				warnings: warnings,
-				// A drain advances through provider continuations, so only the cursor positions these reads.
-				readPage: (cursor: string) => readPage(cursor),
-			},
-		);
-		items = drained.items;
-		paged = drained.paged;
-		allMetadata = drained.metadata;
-		pageFetchFailed = drained.fetchFailed;
-	}
-
-	const assessment = mergeAssessmentInto(warnings, options.providerId, domain, options.connectionId, allMetadata);
-	// Never advertise `hasMore` without a continuation the caller can act on. The account-wide read has no
-	// page to synthesize, and neither does a host that doesn't honor a page number — see
-	// {@link IntegrationService.isPageNumberAdvanceable} for which do and why absence of a declared mode
-	// does NOT count as one.
-	const pageAdvanceable =
-		!accountWide && isPageNumberAdvanceable(providersMetadata[options.providerId]?.pullRequestsPagingMode);
-	const continuation = resolveContinuation(paged, pageAdvanceable ? paged.page.currentPage + 1 : undefined);
-	// A single-page provider read that couldn't confirm completeness sets `paging.truncated`; surface it
-	// as a terminal `page.truncated` (not `hasMore`, which has no cursor to advance) so the caller knows
-	// the page may be incomplete. Metadata incompleteness is an independent source of the same signal.
-	const truncated = continuation.truncated || assessment.truncated;
-	if (truncated && warnings.length === 0) {
-		// `exhausted`, never `page-budget`: a paged read has no budget the caller can raise. Ordinary
-		// continuation is already expressed by `hasMore`/`cursor`, so reaching here means this page itself
-		// couldn't be completed — raising anything would return the same page.
-		warnings.push(
-			truncationWarning(
-				options.providerId,
-				domain,
-				options.connectionId,
-				'Pull request',
-				assessment.fetchFailed || pageFetchFailed ? 'interrupted' : 'exhausted',
-			),
-		);
-	}
-	// A metadata omission from an earlier page asserts the read succeeded; a later page may since have failed.
-	reconcileOmissionsWithFailure(warnings, assessment.fetchFailed || pageFetchFailed);
-	const currentAccountId = items.some(pr => pr.author != null)
-		? await getCurrentAccountId(integration, options.connectionId)
-		: undefined;
-	return {
-		// Normalize the raw provider-apis PRs to the GitLens-owned shape at the surface boundary.
-		items: items.map(pr => fromProviderPullRequest(pr, integration, { currentAccountId: currentAccountId })),
-		warnings: warnings,
-		// The account-wide read can't take a page size, so don't echo the requested `itemsPerPage` as if it
-		// had been applied — report what came back.
-		page: {
-			...paged.page,
-			// Positional, per ProviderPageInfo.currentPage: the drain (above) already advanced `paged.page`,
-			// and a caller-threaded cursor advanced the provider, so neither leaves a cursor-only read stuck
-			// reporting page 1.
-			currentPage: resolveCurrentPage({
-				providerPage: paged.page.currentPage,
-				requestedPage: page,
-				suppliedCursor: options.cursor,
-				pageAdvanceable: pageAdvanceable,
-			}),
-			itemsPerPage: accountWide ? items.length : paged.page.itemsPerPage,
-			truncated: truncated || undefined,
-		},
-		hasMore: continuation.hasMore,
-		cursor: continuation.cursor,
-		// A metadata failure means items are incomplete even when the read didn't throw; a thrown error with
-		// no recovered value is the pre-existing failure case.
-		fetchFailed: assessment.fetchFailed || pageFetchFailed || undefined,
-	};
-}

package/src/plus/integrations/reads/resolveRepository.ts

@@ -1,272 +0,0 @@
-import type { RemoteProviderConfig } from '../../../git/remotes/matcher.js';
-import { createRemoteProviderMatcher } from '../../../git/remotes/matcher.js';
-import { parseGitRemoteUrl } from '../../../git/utils/remote.utils.js';
-import type { IntegrationIds } from '../constants.js';
-import { GitCloudHostIntegrationId, GitSelfManagedHostIntegrationId } from '../constants.js';
-import { AuthenticationError, RequestNotFoundError } from '../errors.js';
-import { isIssuesIntegration } from '../models/issuesIntegration.js';
-import { isAzureCloudDomain, isBitbucketCloudDomain, isGitHubDotCom, isGitLabDotCom } from '../providers/models.js';
-import type { RepositoryIdentity, RepositoryResolution, ResolveRepositoryResult } from '../results.js';
-import { toProviderWarning } from '../results.js';
-import { hostFromDomain } from '../utils/domain.utils.js';
-import {
-	getIntegrationIdForRemote,
-	isGitCloudHostIntegrationId,
-	isGitSelfManagedHostIntegrationId,
-	remoteProviderTypeForConfig,
-	remoteProviderTypeForIntegration,
-} from '../utils/integration.utils.js';
-import type { RepositoryResolutionContext } from './context.js';
-import { noConnectionWarning } from './warnings.js';
-
-/**
- * Resolution of a remote URL to a provider repository identity — the facade's equivalent of `gk repo resolve`.
- *
- * Unlike every other read here, this one's input is REPOSITORY data, so most of the code below is about not
- * letting that data choose the credentials: an explicit cloud `providerId` must agree with the remote's canonical
- * host, and a self-managed host resolves only against a domain the user already authenticated. The
- * `host-mismatch` returns are those guards, not edge cases — resolving `owner/repo` against the wrong account
- * would hand back a confidently wrong identity and seed the domain-keyed instance cache from remote data.
- */
-export async function resolveRepository(
-	ctx: RepositoryResolutionContext,
-	options: {
-		providerId?: IntegrationIds;
-		remoteUrl: string;
-		host?: string;
-		connectionId?: string;
-		/**
-		 * Explicit self-managed host domain used to select the integration instance. Used only when the requested
-		 * connection has no configured domain; it must come from the trusted authentication configuration, not
-		 * repository or remote data.
-		 */
-		domain?: string;
-	},
-): Promise<ResolveRepositoryResult> {
-	const result = (status: RepositoryResolution['status']): ResolveRepositoryResult => ({
-		resolution: { status: status },
-	});
-
-	const [scheme, parsedDomain, path] = parseGitRemoteUrl(options.remoteUrl);
-	const parsedHost = hostFromDomain(parsedDomain);
-	const explicitHost = hostFromDomain(options.host);
-	if (parsedHost != null && explicitHost != null && parsedHost !== explicitHost) {
-		return result('host-mismatch');
-	}
-
-	const matcherDomain = parsedDomain || options.host || '';
-
-	// An explicit cloud provider must agree with the remote's canonical cloud host. Without this guard the
-	// synthetic matcher below can reinterpret, for example, a gitlab.com URL as GitHub and then resolve a
-	// homonymous owner/repo through the wrong account. Match once without caller configs/synthetic entries;
-	// Azure's matcher also normalizes ssh.dev.azure.com and vs-ssh.visualstudio.com to their web host.
-	if (options.providerId != null && isGitCloudHostIntegrationId(options.providerId)) {
-		const nativeProvider = createRemoteProviderMatcher([])(options.remoteUrl, matcherDomain, path, scheme);
-		const nativeId = nativeProvider != null ? getIntegrationIdForRemote(nativeProvider) : undefined;
-		const nativeDomain = nativeProvider?.domain ?? matcherDomain;
-		const canonicalHost =
-			options.providerId === GitCloudHostIntegrationId.GitHub
-				? isGitHubDotCom(nativeDomain)
-				: options.providerId === GitCloudHostIntegrationId.GitLab
-					? isGitLabDotCom(nativeDomain)
-					: options.providerId === GitCloudHostIntegrationId.Bitbucket
-						? isBitbucketCloudDomain(nativeDomain)
-						: isAzureCloudDomain(nativeDomain);
-		if (nativeId !== options.providerId || !canonicalHost) return result('host-mismatch');
-	}
-
-	const provider = createRemoteProviderMatcher(buildMatcherConfigs(ctx, options, parsedDomain))(
-		options.remoteUrl,
-		matcherDomain,
-		path,
-		scheme,
-	);
-	if (provider == null) return result('invalid-remote-url');
-
-	let id = options.providerId ?? getIntegrationIdForRemote(provider);
-	// Custom Azure DevOps Server domains matched via getRemoteConfigs return undefined from
-	// getIntegrationIdForRemote because the provider is marked custom; map them to the server id so the
-	// project-scoped lookup uses that host's configured connection and API base URL.
-	if (id == null && provider.id === 'azure-devops' && provider.custom) {
-		id = GitSelfManagedHostIntegrationId.AzureDevOpsServer;
-	}
-	if (id == null) return result('unsupported-provider');
-
-	const owner = provider.owner;
-	const name = provider.repoName;
-	if (owner == null || name == null) return result('invalid-remote-url');
-
-	// On a self-managed host, resolve only against a TRUSTED host: the pinned connection's configured
-	// domain, the explicit `domain`, or — when neither was supplied — a configured host matching the
-	// remote's. That last case keeps `remoteUrl` (repository-supplied) out of the trusted path: it selects
-	// among hosts the user already authenticated and can never introduce a new one. Resolving `owner/repo`
-	// against some other host's account would, if that host has the same owner/repo, return a confidently
-	// wrong identity — and would seed the domain-keyed integration cache (never evicted before dispose) with
-	// an entry derived from repository data.
-	const urlHost = hostFromDomain(provider.domain);
-	// Normalize BOTH sides before comparing: a stored connection domain is usually a full URL
-	// (`https://git.example.com`) while `urlHost` is already a bare host, so a raw compare would fail on
-	// scheme/trailing-slash alone and wrongly reject a correctly-configured connection.
-	let trustedHost =
-		options.connectionId != null || options.domain != null
-			? hostFromDomain(ctx.resolveDomainForRead(id, options.connectionId, options.domain))
-			: undefined;
-	if (isGitSelfManagedHostIntegrationId(id)) {
-		const configuredHosts = ctx.getConfigured(id).map(c => hostFromDomain(c.domain));
-		if (trustedHost == null && urlHost != null) {
-			trustedHost = configuredHosts.find(host => host === urlHost);
-		}
-		// A configured host that doesn't match the remote's is a genuine mismatch. With nothing configured
-		// there is no host to mismatch against — it's simply not connected, so fall through to the
-		// `unauthorized` path below (still WITHOUT resolving by the URL domain, so repo data can't seed the
-		// cache).
-		if (trustedHost == null && configuredHosts.length !== 0) return result('host-mismatch');
-		if (trustedHost != null && urlHost != null && trustedHost !== urlHost) return result('host-mismatch');
-	}
-
-	let integration;
-	try {
-		// Resolve the instance through the trusted target (as `getIntegrationForRead` does):
-		// `resolveReadSession` looks the session up against the instance's domain-scoped descriptor, so
-		// selecting the instance by the URL domain could miss the session and degrade to `no-connection`.
-		integration = isGitSelfManagedHostIntegrationId(id)
-			? trustedHost != null
-				? await ctx.getIntegrationForRead(id, options.connectionId, trustedHost)
-				: undefined
-			: await ctx.getIntegrationForDomain(id, provider.domain);
-	} catch {
-		integration = undefined;
-	}
-	if (integration == null) {
-		// Attach a warning, as the thrown-AuthenticationError branch below does: a consumer driving auth
-		// recovery off `warning.kind` would otherwise get nothing for an unresolvable target.
-		return {
-			resolution: {
-				status: 'unauthorized',
-				warning: noConnectionWarning(id, provider.domain, options.connectionId),
-			},
-		};
-	}
-	// Issue trackers have no `getRepo` client; a git host without `getRepoFn` leaves `getRepoInfo`
-	// undefined. Either way this provider can't resolve repositories.
-	if (isIssuesIntegration(integration) || integration.getRepoInfo == null) {
-		return result('unsupported-provider');
-	}
-
-	// Azure repos are org + project scoped; the remote provider exposes project as `providerDesc.repoDomain`.
-	const project = provider.id === 'azure-devops' ? provider.providerDesc?.repoDomain : undefined;
-	const domain = provider.domain;
-
-	// Azure's lookup is project-scoped and returns `undefined` without one, which the connection-gap branch
-	// below would misreport as `unauthorized` (driving a pointless reconnect). A remote URL that carries no
-	// project simply can't address an Azure repo.
-	if (provider.id === 'azure-devops' && project == null) return result('invalid-remote-url');
-
-	try {
-		const repo = await integration.getRepoInfo({
-			owner: owner,
-			name: name,
-			project: project,
-			connectionId: options.connectionId,
-		});
-		if (repo == null) {
-			// `getRepoInfo` returns undefined only when no session could be resolved (not connected, or the
-			// requested connection is gone) — a real 404 throws below. So this is a connection gap. Attach a
-			// warning so a consumer driving auth recovery off `warning.kind` sees the same signal it gets from
-			// the thrown-AuthenticationError branch below; without it, the most common unauthorized case is
-			// silent.
-			return {
-				resolution: {
-					status: 'unauthorized',
-					warning: noConnectionWarning(id, domain, options.connectionId),
-				},
-			};
-		}
-
-		// Prefer the provider's canonical namespace/name (GitHub's REST/GraphQL lookup follows the 301
-		// rename redirect, so a stale old name resolves to the new canonical identity), falling back to the
-		// parsed remote when the response omits them. `renamed` is a case-insensitive compare of input vs
-		// canonical, mirroring gkcli's `EqualFold`, so hosts that merely echo the input casing (e.g.
-		// Bitbucket Server/Azure) don't get spuriously flagged.
-		const canonicalOwner = repo.namespace || owner;
-		const canonicalName = repo.name || name;
-		const renamed =
-			canonicalOwner.toLowerCase() !== owner.toLowerCase() || canonicalName.toLowerCase() !== name.toLowerCase();
-
-		const identity: RepositoryIdentity = {
-			providerId: id,
-			domain: domain,
-			owner: canonicalOwner,
-			name: canonicalName,
-			project: project,
-			remoteUrl: options.remoteUrl,
-			renamed: renamed,
-		};
-		return { resolution: { status: 'resolved', identity: identity } };
-	} catch (ex) {
-		// Order matters: 404 throws RequestNotFoundError (not `undefined`), so check not-found before auth
-		// and before the generic 5xx/unknown bucket — never classify a 401/403 as not-found.
-		let resolution: RepositoryResolution;
-		if (ex instanceof RequestNotFoundError) {
-			resolution = { status: 'not-found' };
-		} else if (ex instanceof AuthenticationError) {
-			resolution = { status: 'unauthorized', warning: toProviderWarning(id, domain, options.connectionId, ex) };
-		} else {
-			resolution = { status: 'undetermined', warning: toProviderWarning(id, domain, options.connectionId, ex) };
-		}
-		return { resolution: resolution };
-	}
-}
-
-/**
- * The remote-matcher configs for this resolution: the user's own host remote configs (self-managed/custom
- * domains), plus a synthetic exact-domain entry for an explicit `providerId` + host so a custom domain still maps
- * to the right provider for path parsing.
- */
-function buildMatcherConfigs(
-	ctx: RepositoryResolutionContext,
-	options: { providerId?: IntegrationIds; host?: string },
-	parsedDomain: string,
-): RemoteProviderConfig[] {
-	const configs: RemoteProviderConfig[] = [];
-	for (const cfg of ctx.getRemoteConfigs()) {
-		const type = remoteProviderTypeForConfig(cfg.type);
-		if (type == null) continue;
-
-		// Forward both domain- and regex-based custom remotes (carrying any protocol override), so a
-		// regex-configured host resolves instead of falling through to `unsupported`.
-		if (cfg.domain) {
-			configs.push({ type: type, domain: cfg.domain, protocol: cfg.protocol });
-		} else if (cfg.regex) {
-			configs.push({ type: type, regex: cfg.regex, protocol: cfg.protocol });
-		}
-	}
-	if (options.providerId == null) return configs;
-
-	const type = remoteProviderTypeForIntegration(options.providerId);
-	const domain = parsedDomain || options.host;
-	if (type == null || !domain) return configs;
-
-	// The synthetic exact-domain entry is unshifted to the front, so it wins the match over the user's own
-	// config for the same host. Carry that config's protocol override across (matched by domain or regex,
-	// mirroring `ignoreSSLErrors`) so a self-managed host configured for a custom protocol — e.g. plain
-	// `http` — isn't silently downgraded to the provider default here.
-	const lowerDomain = domain.toLowerCase();
-	const protocol = configs.find(c => {
-		if (c.type !== type) return false;
-		if (c.domain != null) return c.domain.toLowerCase() === lowerDomain;
-
-		// Truthy (not just non-null): an empty regex would compile to a match-everything pattern.
-		if (c.regex) {
-			try {
-				return new RegExp(c.regex, 'i').test(lowerDomain);
-			} catch {
-				return false;
-			}
-		}
-
-		return false;
-	})?.protocol;
-	configs.unshift({ type: type, domain: domain, protocol: protocol });
-	return configs;
-}