@gitkraken/core-gitlens 0.5.116 → 0.7.0

package/dist/plus/integrations/reads/broaden.js

@@ -1,454 +1,335 @@
-import { effectiveIssueSort } from '../../../git/utils/issue.utils.js';
-import { mapBounded } from '../../../utils/promise.js';
-import { mergeAssessmentInto } from '../collectionMetadata.js';
-import { providerFanOutConcurrency } from '../constants.js';
-import { appendDedupedWarning } from '../results.js';
-import { hostFromDomain } from '../utils/domain.utils.js';
-import { isGitHostIntegration, isIssuesHostIntegrationId } from '../utils/integration.utils.js';
-import { getBroadenIssuesCursor, isBroadenIssuesOrgExhausted, toBroadenIssuesCursor } from './cursors.js';
-import { drainRepositories, runCaptured } from './drains.js';
-import { resolveIssueSearchScope, supportsFilteredIssueSearch } from './filters.js';
-import { resolveContinuation, toProviderPageInfo, usableCursor } from './paging.js';
-import { gitHostOnlySurfaceWarning, issueSearchCapResultWarning, issuesUnsupportedWarning, noConnectionWarning, otherWarning, truncationWarning, unsupportedIssueSearchCriteriaWarning, unusableSearchScopeMessage, } from './warnings.js';
+import { mapBounded } from "../../../utils/promise.js";
+import { effectiveIssueSort } from "../../../git/utils/issue.utils.js";
+import { appendDedupedWarning } from "../results.js";
+import { mergeAssessmentInto } from "../collectionMetadata.js";
+import "../constants.js";
+import { isGitHostIntegration, isIssuesHostIntegrationId } from "../utils/integration.utils.js";
+import { hostFromDomain } from "../utils/domain.utils.js";
+import { resolveContinuation, toProviderPageInfo, usableCursor } from "./paging.js";
+import { getBroadenIssuesCursor, isBroadenIssuesOrgExhausted, toBroadenIssuesCursor } from "./cursors.js";
+import { gitHostOnlySurfaceWarning, issueSearchCapResultWarning, issuesUnsupportedWarning, noConnectionWarning, otherWarning, truncationWarning, unsupportedIssueSearchCriteriaWarning, unusableSearchScopeMessage } from "./warnings.js";
+import { drainRepositories, runCaptured } from "./drains.js";
+import { resolveIssueSearchScope, supportsFilteredIssueSearch } from "./filters.js";
+//#region ../plus/integrations/src/reads/broaden.ts
 /**
- * Accumulates provider attribution across the rounds of a page-number traversal.
- *
- * The three sets are mutually exclusive per provider and the ordering rules are what keep them so: a provider
- * that failed in one round but broadened in another is INCOMPLETE, not failed, whichever round reported first.
- */
-class ProviderAttribution {
-    broadened = new Set();
-    failed = new Set();
-    incomplete = new Set();
-    merge(result) {
-        for (const providerId of result.failedProviderIds) {
-            if (this.broadened.has(providerId) || result.broadenedProviderIds.includes(providerId)) {
-                this.incomplete.add(providerId);
-            }
-            else {
-                this.failed.add(providerId);
-            }
-        }
-        for (const providerId of result.incompleteProviderIds) {
-            this.failed.delete(providerId);
-            this.incomplete.add(providerId);
-        }
-        for (const providerId of result.broadenedProviderIds) {
-            this.broadened.add(providerId);
-            if (this.failed.delete(providerId)) {
-                this.incomplete.add(providerId);
-            }
-        }
-    }
-    toResultFields() {
-        return {
-            broadenedProviderIds: [...this.broadened],
-            failedProviderIds: [...this.failed],
-            incompleteProviderIds: [...this.incomplete],
-        };
-    }
-}
-export async function broadenIssues(ctx, options) {
-    const page = Math.max(1, Math.trunc(options.page ?? 1));
-    // Kepler's existing contract persists only a page number. When no opaque continuation was supplied,
-    // advance through prior pages internally so cursor-only providers still return the requested page.
-    // Each recursive call below carries a cursor, so it bypasses this block and performs exactly one round.
-    if (options.cursor == null && page > 1) {
-        return traverseToRequestedPage(ctx, options, page);
-    }
-    const results = await mapBounded(options.orgs, providerFanOutConcurrency, org => readOrgSlice(ctx, options, org, page));
-    const items = [];
-    const warnings = [];
-    const broadenedProviderIds = new Set();
-    const problemProviderIds = new Set();
-    const cursors = [];
-    const exhausted = [];
-    let hasMore = false;
-    let fetchFailed = false;
-    let truncated = false;
-    for (const result of results) {
-        if (result == null) {
-            continue;
-        }
-        items.push(...result.items);
-        // Deduped across orgs: several orgs of one provider commonly fail the same way (one expired token, one
-        // rate limit), producing the identical warning per slice, and the array's contract is that no two entries
-        // are equal — `traverseToRequestedPage` already dedupes when it folds these same warnings across rounds.
-        for (const warning of result.warnings) {
-            appendDedupedWarning(warnings, warning);
-        }
-        for (const id of result.broadenedProviderIds) {
-            broadenedProviderIds.add(id);
-        }
-        if (result.nextCursor != null || result.retryPage != null) {
-            cursors.push({
-                providerId: result.providerId,
-                org: result.org,
-                connectionId: result.connectionId,
-                domain: result.domain,
-                cursor: result.nextCursor,
-                retryPage: result.retryPage,
-            });
-        }
-        if (result.exhausted) {
-            exhausted.push({
-                providerId: result.providerId,
-                org: result.org,
-                connectionId: result.connectionId,
-                domain: result.domain,
-            });
-        }
-        if (result.hasMore) {
-            hasMore = true;
-        }
-        if (result.fetchFailed) {
-            fetchFailed = true;
-        }
-        if (result.truncated) {
-            truncated = true;
-        }
-        if (result.fetchFailed || result.truncated) {
-            problemProviderIds.add(result.providerId);
-        }
-    }
-    const cursor = toBroadenIssuesCursor(cursors, exhausted, options.orgs.length);
-    const failedProviderIds = [];
-    const incompleteProviderIds = [];
-    for (const providerId of problemProviderIds) {
-        if (broadenedProviderIds.has(providerId)) {
-            incompleteProviderIds.push(providerId);
-        }
-        else {
-            failedProviderIds.push(providerId);
-        }
-    }
-    return {
-        items: items,
-        warnings: warnings,
-        // `currentPage` is positional, per ProviderPageInfo.currentPage: this fan-out has no provider-reported
-        // page of its own (its cursor is a per-org bundle, not a page), so the position is the one the caller
-        // addressed — the `page` it supplied, or the page the internal traversal advanced to.
-        page: { currentPage: page, itemsPerPage: items.length, truncated: truncated || undefined },
-        // `hasMore` promises a resumable continuation, so it must be true ONLY when a real cursor was
-        // produced. Repo-drain truncation (a backstop hit with no persisted repo cursor) can't be resumed —
-        // re-invoking would re-drain the same repos and repeat issues — so it is surfaced as the terminal
-        // `page.truncated` incompleteness signal instead of `hasMore`, matching listRepos. Guard `hasMore`
-        // against a missing cursor so we never advertise a continuation the caller can't make.
-        hasMore: hasMore && cursor != null,
-        cursor: cursor,
-        fetchFailed: fetchFailed || undefined,
-        broadenedProviderIds: [...broadenedProviderIds],
-        failedProviderIds: failedProviderIds,
-        incompleteProviderIds: incompleteProviderIds,
-        fanOutCount: options.orgs.length,
-    };
+* Accumulates provider attribution across the rounds of a page-number traversal.
+*
+* The three sets are mutually exclusive per provider and the ordering rules are what keep them so: a provider
+* that failed in one round but broadened in another is INCOMPLETE, not failed, whichever round reported first.
+*/
+var ProviderAttribution = class {
+	broadened = /* @__PURE__ */ new Set();
+	failed = /* @__PURE__ */ new Set();
+	incomplete = /* @__PURE__ */ new Set();
+	merge(result) {
+		for (const providerId of result.failedProviderIds) if (this.broadened.has(providerId) || result.broadenedProviderIds.includes(providerId)) this.incomplete.add(providerId);
+		else this.failed.add(providerId);
+		for (const providerId of result.incompleteProviderIds) {
+			this.failed.delete(providerId);
+			this.incomplete.add(providerId);
+		}
+		for (const providerId of result.broadenedProviderIds) {
+			this.broadened.add(providerId);
+			if (this.failed.delete(providerId)) this.incomplete.add(providerId);
+		}
+	}
+	toResultFields() {
+		return {
+			broadenedProviderIds: [...this.broadened],
+			failedProviderIds: [...this.failed],
+			incompleteProviderIds: [...this.incomplete]
+		};
+	}
+};
+async function broadenIssues(ctx, options) {
+	const page = Math.max(1, Math.trunc(options.page ?? 1));
+	if (options.cursor == null && page > 1) return traverseToRequestedPage(ctx, options, page);
+	const results = await mapBounded(options.orgs, 6, (org) => readOrgSlice(ctx, options, org, page));
+	const items = [];
+	const warnings = [];
+	const broadenedProviderIds = /* @__PURE__ */ new Set();
+	const problemProviderIds = /* @__PURE__ */ new Set();
+	const cursors = [];
+	const exhausted = [];
+	let hasMore = false;
+	let fetchFailed = false;
+	let truncated = false;
+	for (const result of results) {
+		if (result == null) continue;
+		items.push(...result.items);
+		for (const warning of result.warnings) appendDedupedWarning(warnings, warning);
+		for (const id of result.broadenedProviderIds) broadenedProviderIds.add(id);
+		if (result.nextCursor != null || result.retryPage != null) cursors.push({
+			providerId: result.providerId,
+			org: result.org,
+			connectionId: result.connectionId,
+			domain: result.domain,
+			cursor: result.nextCursor,
+			retryPage: result.retryPage
+		});
+		if (result.exhausted) exhausted.push({
+			providerId: result.providerId,
+			org: result.org,
+			connectionId: result.connectionId,
+			domain: result.domain
+		});
+		if (result.hasMore) hasMore = true;
+		if (result.fetchFailed) fetchFailed = true;
+		if (result.truncated) truncated = true;
+		if (result.fetchFailed || result.truncated) problemProviderIds.add(result.providerId);
+	}
+	const cursor = toBroadenIssuesCursor(cursors, exhausted, options.orgs.length);
+	const failedProviderIds = [];
+	const incompleteProviderIds = [];
+	for (const providerId of problemProviderIds) if (broadenedProviderIds.has(providerId)) incompleteProviderIds.push(providerId);
+	else failedProviderIds.push(providerId);
+	return {
+		items,
+		warnings,
+		page: {
+			currentPage: page,
+			itemsPerPage: items.length,
+			truncated: truncated || void 0
+		},
+		hasMore: hasMore && cursor != null,
+		cursor,
+		fetchFailed: fetchFailed || void 0,
+		broadenedProviderIds: [...broadenedProviderIds],
+		failedProviderIds,
+		incompleteProviderIds,
+		fanOutCount: options.orgs.length
+	};
 }
 /**
- * Advances to page N by re-running the fan-out for each prior page, threading each round's cursor bundle into the
- * next. Only the requested page's items are returned; warnings and provider attribution accumulate across the
- * whole walked prefix, since a failure in an earlier round still means this result is not authoritative.
- */
+* Advances to page N by re-running the fan-out for each prior page, threading each round's cursor bundle into the
+* next. Only the requested page's items are returned; warnings and provider attribution accumulate across the
+* whole walked prefix, since a failure in an earlier round still means this result is not authoritative.
+*/
 async function traverseToRequestedPage(ctx, options, page) {
-    let cursor;
-    const traversalWarnings = [];
-    const attribution = new ProviderAttribution();
-    let traversalFetchFailed = false;
-    let traversalTruncated = false;
-    for (let currentPage = 1; currentPage < page; currentPage++) {
-        const previous = await broadenIssues(ctx, {
-            ...options,
-            page: currentPage,
-            cursor: cursor,
-            // A forced refresh belongs to the logical read, not every cursor-advancement round.
-            forceSync: currentPage === 1 ? options.forceSync : false,
-        });
-        for (const warning of previous.warnings) {
-            appendDedupedWarning(traversalWarnings, warning);
-        }
-        attribution.merge(previous);
-        traversalFetchFailed ||= previous.fetchFailed === true;
-        traversalTruncated ||= previous.page.truncated === true;
-        if (!previous.hasMore || previous.cursor == null) {
-            // The requested page lies past the last continuation: an empty page N, never the last page relabeled.
-            return {
-                items: [],
-                warnings: traversalWarnings,
-                page: { currentPage: page, itemsPerPage: 0, truncated: traversalTruncated || undefined },
-                hasMore: false,
-                fetchFailed: traversalFetchFailed || undefined,
-                ...attribution.toResultFields(),
-                fanOutCount: options.orgs.length,
-            };
-        }
-        cursor = previous.cursor;
-    }
-    const requested = await broadenIssues(ctx, { ...options, page: page, cursor: cursor, forceSync: false });
-    for (const warning of requested.warnings) {
-        appendDedupedWarning(traversalWarnings, warning);
-    }
-    attribution.merge(requested);
-    return {
-        ...requested,
-        warnings: traversalWarnings,
-        page: {
-            ...requested.page,
-            truncated: traversalTruncated || requested.page.truncated === true || undefined,
-        },
-        fetchFailed: traversalFetchFailed || requested.fetchFailed === true || undefined,
-        ...attribution.toResultFields(),
-    };
+	let cursor;
+	const traversalWarnings = [];
+	const attribution = new ProviderAttribution();
+	let traversalFetchFailed = false;
+	let traversalTruncated = false;
+	for (let currentPage = 1; currentPage < page; currentPage++) {
+		const previous = await broadenIssues(ctx, {
+			...options,
+			page: currentPage,
+			cursor,
+			forceSync: currentPage === 1 ? options.forceSync : false
+		});
+		for (const warning of previous.warnings) appendDedupedWarning(traversalWarnings, warning);
+		attribution.merge(previous);
+		traversalFetchFailed ||= previous.fetchFailed === true;
+		traversalTruncated ||= previous.page.truncated === true;
+		if (!previous.hasMore || previous.cursor == null) return {
+			items: [],
+			warnings: traversalWarnings,
+			page: {
+				currentPage: page,
+				itemsPerPage: 0,
+				truncated: traversalTruncated || void 0
+			},
+			hasMore: false,
+			fetchFailed: traversalFetchFailed || void 0,
+			...attribution.toResultFields(),
+			fanOutCount: options.orgs.length
+		};
+		cursor = previous.cursor;
+	}
+	const requested = await broadenIssues(ctx, {
+		...options,
+		page,
+		cursor,
+		forceSync: false
+	});
+	for (const warning of requested.warnings) appendDedupedWarning(traversalWarnings, warning);
+	attribution.merge(requested);
+	return {
+		...requested,
+		warnings: traversalWarnings,
+		page: {
+			...requested.page,
+			truncated: traversalTruncated || requested.page.truncated === true || void 0
+		},
+		fetchFailed: traversalFetchFailed || requested.fetchFailed === true || void 0,
+		...attribution.toResultFields()
+	};
 }
 /**
- * The org-scoped filtered search: ONE request per page, whatever the org contains.
- *
- * Replaces the drain + SDK read for every provider that declares a filtered issue search — the repository drain
- * costs up to 100 requests per org, and the SDK's repo-scoped read past GitHub's result ceiling enters a
- * per-repository recovery walk that can spend 128 more and still return an incomplete set. Measured on an org
- * past that ceiling: 133 requests and 111s, against this read's 10 and 40s. The search reaches the same scope by
- * NAMING the org, so it needs no repositories at all.
- *
- * It is also the more COMPLETE of the two over the window a consumer reads first, despite returning fewer items —
- * see the module docstring's table for the measurement and why that is not a contradiction.
- *
- * `criteria` is omitted entirely, and each half of that is deliberate:
- * - `relationships` OMITTED is what drops the assignee constraint, which is the substitution `includeAllAssignees:
- *   true` performs on the read this replaces. NOT `['any-assignee']`, which means "assigned to somebody" and would
- *   exclude every unassigned issue — the opposite of broadening.
- * - every other criterion left unset resolves to the provider's own default, which is the state this read already
- *   served (open issues only, archived repositories excluded).
- *
- * At the result ceiling this SUCCEEDS and reports how many matched instead of walking for the rest — see the
- * ceiling warning below.
- */
+* The org-scoped filtered search: ONE request per page, whatever the org contains.
+*
+* Replaces the drain + SDK read for every provider that declares a filtered issue search — the repository drain
+* costs up to 100 requests per org, and the SDK's repo-scoped read past GitHub's result ceiling enters a
+* per-repository recovery walk that can spend 128 more and still return an incomplete set. Measured on an org
+* past that ceiling: 133 requests and 111s, against this read's 10 and 40s. The search reaches the same scope by
+* NAMING the org, so it needs no repositories at all.
+*
+* It is also the more COMPLETE of the two over the window a consumer reads first, despite returning fewer items —
+* see the module docstring's table for the measurement and why that is not a contradiction.
+*
+* `criteria` is omitted entirely, and each half of that is deliberate:
+* - `relationships` OMITTED is what drops the assignee constraint, which is the substitution `includeAllAssignees:
+*   true` performs on the read this replaces. NOT `['any-assignee']`, which means "assigned to somebody" and would
+*   exclude every unassigned issue — the opposite of broadening.
+* - every other criterion left unset resolves to the provider's own default, which is the state this read already
+*   served (open issues only, archived repositories excluded).
+*
+* At the result ceiling this SUCCEEDS and reports how many matched instead of walking for the rest — see the
+* ceiling warning below.
+*/
 async function readOrgIssuesViaSearch(integration, org, domain, cursor) {
-    const connectionId = org.connectionId;
-    const captured = await runCaptured(org.providerId, domain, connectionId, () => integration.searchIssuesPageResult({ org: org.name, cursor: cursor }, undefined, connectionId), { warnOnMissingSession: true });
-    // A provider that declares the capability but implements no search hook answers `undefined` with no error.
-    // Reported as the explicit unsupported failure rather than left as a silent empty page, so it can't be mistaken
-    // for an org with no issues — and as the read's `warning`, so the slice treats it as the read failure it is.
-    const warning = captured.warning ??
-        (captured.value == null
-            ? unsupportedIssueSearchCriteriaWarning(org.providerId, domain, connectionId, {
-                reason: 'unsupported-search',
-            })
-            : undefined);
-    const warnings = warning != null ? [warning] : [];
-    let value;
-    if (captured.value != null) {
-        const page = captured.value;
-        value = {
-            items: page.values,
-            hasMore: page.hasMore,
-            cursor: usableCursor(page.cursor),
-            truncated: page.truncated,
-        };
-        // The result ceiling is the one incompleteness this read can QUANTIFY, so it carries the total rather than
-        // a bare "may be incomplete" — which is what lets a consumer say "1.474 matched, showing the 1.000 most
-        // recently updated" instead of silently serving a truncated list. Only when nothing else already explained
-        // the incompleteness, and only the ceiling gets the number: any other cause falls back to the generic
-        // wording rather than reporting a limit it didn't hit. `exhausted`: nothing this read exposes would return
-        // the withheld items.
-        if (page.truncated && warnings.length === 0) {
-            warnings.push(issueSearchCapResultWarning(org.providerId, domain, connectionId, page.totalCount, effectiveIssueSort(undefined)) ?? truncationWarning(org.providerId, domain, connectionId, 'Issue search', 'exhausted'));
-        }
-    }
-    return { value: value, warning: warning, warnings: warnings, fetchFailed: false, truncated: false };
+	const connectionId = org.connectionId;
+	const captured = await runCaptured(org.providerId, domain, connectionId, () => integration.searchIssuesPageResult({
+		org: org.name,
+		cursor
+	}, void 0, connectionId), { warnOnMissingSession: true });
+	const warning = captured.warning ?? (captured.value == null ? unsupportedIssueSearchCriteriaWarning(org.providerId, domain, connectionId, { reason: "unsupported-search" }) : void 0);
+	const warnings = warning != null ? [warning] : [];
+	let value;
+	if (captured.value != null) {
+		const page = captured.value;
+		value = {
+			items: page.values,
+			hasMore: page.hasMore,
+			cursor: usableCursor(page.cursor),
+			truncated: page.truncated
+		};
+		if (page.truncated && warnings.length === 0) warnings.push(issueSearchCapResultWarning(org.providerId, domain, connectionId, page.totalCount, effectiveIssueSort(void 0)) ?? truncationWarning(org.providerId, domain, connectionId, "Issue search", "exhausted"));
+	}
+	return {
+		value,
+		warning,
+		warnings,
+		fetchFailed: false,
+		truncated: false
+	};
 }
 /**
- * The original engine: drain the org's repositories, then read the issues across them.
- *
- * Kept for a provider that declares NO filtered issue search (Azure DevOps, GitLab), where refusing the org would
- * be a regression rather than a saving. Its cost, and the arbitrary subset it serves past the result ceiling, are
- * what {@link readOrgIssuesViaSearch} exists to avoid — see the module docstring's measurement. Those providers
- * keep both, because on them there is nothing better to switch to.
- */
+* The original engine: drain the org's repositories, then read the issues across them.
+*
+* Kept for a provider that declares NO filtered issue search (Azure DevOps, GitLab), where refusing the org would
+* be a regression rather than a saving. Its cost, and the arbitrary subset it serves past the result ceiling, are
+* what {@link readOrgIssuesViaSearch} exists to avoid — see the module docstring's measurement. Those providers
+* keep both, because on them there is nothing better to switch to.
+*/
 async function readOrgIssuesViaRepoDrain(integration, org, domain, cursor) {
-    const connectionId = org.connectionId;
-    const reposDrain = await drainRepositories(integration, org.providerId, domain, org.name, undefined, connectionId, 100);
-    const warnings = [...reposDrain.warnings];
-    const repos = reposDrain.repos.map(r => ({ ...r }));
-    if (repos.length === 0) {
-        return {
-            warnings: warnings,
-            fetchFailed: reposDrain.fetchFailed,
-            truncated: reposDrain.truncated,
-            nothingToRead: true,
-        };
-    }
-    // Broaden = "all visible": drop the assigned-to-me filter so unassigned issues are included.
-    const captured = await runCaptured(org.providerId, domain, connectionId, () => 
-    // Normalized shapes seam, uniform with listIssuesPage.
-    integration.getMyIssuesForReposAsShapesResult(repos, { includeAllAssignees: true, cursor: cursor }, connectionId), { warnOnMissingSession: true });
-    if (captured.warning != null) {
-        warnings.push(captured.warning);
-    }
-    const assessment = mergeAssessmentInto(warnings, org.providerId, domain, connectionId, captured.value?.metadata);
-    let value;
-    if (captured.value != null) {
-        const paged = toProviderPageInfo(captured.value.values.length, captured.value.paging);
-        value = {
-            items: captured.value.values,
-            hasMore: paged.hasMore,
-            cursor: paged.cursor,
-            // Carry a truncation signal from the issue read too: a provider that couldn't confirm it drained a
-            // repo (`paging.truncated`) means this org's issues may be incomplete, on top of any repo-drain
-            // truncation already captured above.
-            truncated: paged.truncated || assessment.truncated,
-        };
-    }
-    return {
-        value: value,
-        warning: captured.warning,
-        warnings: warnings,
-        fetchFailed: reposDrain.fetchFailed || assessment.fetchFailed,
-        truncated: reposDrain.truncated,
-    };
+	const connectionId = org.connectionId;
+	const reposDrain = await drainRepositories(integration, org.providerId, domain, org.name, void 0, connectionId, 100);
+	const warnings = [...reposDrain.warnings];
+	const repos = reposDrain.repos.map((r) => ({ ...r }));
+	if (repos.length === 0) return {
+		warnings,
+		fetchFailed: reposDrain.fetchFailed,
+		truncated: reposDrain.truncated,
+		nothingToRead: true
+	};
+	const captured = await runCaptured(org.providerId, domain, connectionId, () => integration.getMyIssuesForReposAsShapesResult(repos, {
+		includeAllAssignees: true,
+		cursor
+	}, connectionId), { warnOnMissingSession: true });
+	if (captured.warning != null) warnings.push(captured.warning);
+	const assessment = mergeAssessmentInto(warnings, org.providerId, domain, connectionId, captured.value?.metadata);
+	let value;
+	if (captured.value != null) {
+		const paged = toProviderPageInfo(captured.value.values.length, captured.value.paging);
+		value = {
+			items: captured.value.values,
+			hasMore: paged.hasMore,
+			cursor: paged.cursor,
+			truncated: paged.truncated || assessment.truncated
+		};
+	}
+	return {
+		value,
+		warning: captured.warning,
+		warnings,
+		fetchFailed: reposDrain.fetchFailed || assessment.fetchFailed,
+		truncated: reposDrain.truncated
+	};
 }
 /**
- * Reads one org's visible issues, through the org-scoped filtered search where the provider has one and through
- * the repository drain where it doesn't. Everything below the engine — the position, the retry slot, the
- * attribution and the exhaustion mark — is the same on both paths.
- */
+* Reads one org's visible issues, through the org-scoped filtered search where the provider has one and through
+* the repository drain where it doesn't. Everything below the engine — the position, the retry slot, the
+* attribution and the exhaustion mark — is the same on both paths.
+*/
 async function readOrgSlice(ctx, options, org, page) {
-    const connectionId = org.connectionId;
-    const requestedDomain = org.domain;
-    const cursorDomain = hostFromDomain(requestedDomain) ?? requestedDomain;
-    // An org slice that yielded no issues and has nothing to continue: the org's identity (which the
-    // aggregation above keys the per-org cursor bundle by) plus why it produced nothing. `exhausted` marks
-    // an org a prior round already drained, so it stays skipped rather than being re-read from page 1.
-    const barrenSlice = (warnings, flags) => ({
-        items: [],
-        warnings: warnings,
-        broadenedProviderIds: [],
-        providerId: org.providerId,
-        org: org.name,
-        connectionId: connectionId,
-        domain: cursorDomain,
-        nextCursor: undefined,
-        hasMore: false,
-        exhausted: flags?.exhausted ?? false,
-        fetchFailed: flags?.fetchFailed ?? false,
-        truncated: flags?.truncated ?? false,
-    });
-    if (isIssuesHostIntegrationId(org.providerId)) {
-        return barrenSlice([gitHostOnlySurfaceWarning(org.providerId, requestedDomain, connectionId, 'issue broadening')], {
-            fetchFailed: true,
-        });
-    }
-    const integration = await ctx.getIntegrationForRead(org.providerId, connectionId, requestedDomain);
-    if (integration == null) {
-        // A requested connection or domain that can't be resolved is a broken target — surface it as a
-        // warning + fetchFailed rather than dropping the org silently.
-        const early = ctx.earlyReturnConnectionWarnings(org.providerId, connectionId, requestedDomain);
-        return barrenSlice(early.warnings.length > 0
-            ? early.warnings
-            : [noConnectionWarning(org.providerId, requestedDomain, connectionId)], { fetchFailed: true });
-    }
-    if (!isGitHostIntegration(integration)) {
-        return barrenSlice([gitHostOnlySurfaceWarning(org.providerId, requestedDomain, connectionId, 'issue broadening')], {
-            fetchFailed: true,
-        });
-    }
-    // A git host whose issue tracker is deprecated (Bitbucket) exposes no issues here — surface a
-    // warning + fetchFailed and skip it (no repo drain), so broadening never serves a legacy source.
-    if (!integration.supportsIssues) {
-        return barrenSlice([
-            issuesUnsupportedWarning(org.providerId, ctx.domainForRead(integration, org.providerId, connectionId, requestedDomain), connectionId),
-        ], { fetchFailed: true });
-    }
-    // An org name NEITHER engine can use, refused before either is chosen. Declining the search for it is not
-    // enough, because falling through to the repository drain is not the safe default it looks like: the drain
-    // passes the SAME name to the org repository read, which matches nothing and reports `nothingToRead` — an
-    // org that reads as empty, with no warning and no `fetchFailed`, after up to 100 requests. Indistinguishable
-    // from an org that genuinely has no issues, and strictly worse than saying so.
-    //
-    // EVERY rejection, not just `unusable-scope`: with no repositories and no criteria the only other reachable
-    // one is `unscoped`, which here means exactly `org.name === ''` — the same bad outcome by the same route, so
-    // drawing the line between them would leave the emptiest case on the wrong side of the rule. (`repo-ids`
-    // cannot arise: no repositories are passed.) Refusing them all is also what lets the engine choice below be
-    // a plain capability question again, since no rejection survives this point.
-    const scopeRejection = resolveIssueSearchScope(undefined, org.name, undefined).rejection;
-    if (scopeRejection != null) {
-        return barrenSlice([
-            otherWarning(org.providerId, ctx.domainForRead(integration, org.providerId, connectionId, requestedDomain), connectionId, scopeRejection.reason === 'unusable-scope'
-                ? unusableSearchScopeMessage('issue broadening scopes', scopeRejection.scopes)
-                : 'Issue broadening must name an organization; one was supplied with an empty name.'),
-        ], { fetchFailed: true });
-    }
-    // An org a prior round already drained must not be re-read: cursor-only providers would answer a
-    // fresh page-1 request with their first page again, duplicating issues across rounds. Skip it
-    // before any work (including the repo drain) and keep it marked exhausted so it stays skipped
-    // for the rest of the fan-out.
-    if (isBroadenIssuesOrgExhausted(options.cursor, org, options.orgs.length)) {
-        return barrenSlice([], { exhausted: true });
-    }
-    await ctx.forceRefreshIfRequested(integration, options.forceSync, connectionId);
-    const domain = ctx.domainForRead(integration, org.providerId, connectionId, requestedDomain);
-    const cursor = getBroadenIssuesCursor(options.cursor, org, page, options.orgs.length);
-    // A plain capability question, and only because the refusal above has already turned away every org whose
-    // name the scope rule rejects. That order matters: `readOrgIssuesViaSearch` calls the integration's
-    // `searchIssuesPageResult` directly rather than the `searchIssuesPage` read, and that method documents its
-    // scope as already validated ("the facade rejects it before here") — so an unvalidated name reaching it would
-    // go straight to the provider query that sanitizes it.
-    const read = supportsFilteredIssueSearch(org.providerId)
-        ? await readOrgIssuesViaSearch(integration, org, domain, cursor)
-        : await readOrgIssuesViaRepoDrain(integration, org, domain, cursor);
-    if (read.nothingToRead === true) {
-        return barrenSlice(read.warnings, { fetchFailed: read.fetchFailed, truncated: read.truncated });
-    }
-    const warnings = read.warnings;
-    let issuesFetchFailed = read.fetchFailed || (read.warning != null && read.value == null);
-    const items = [];
-    let hasMore = false;
-    let nextCursor;
-    let retryPage;
-    let issuesTruncated = false;
-    if (read.value != null) {
-        items.push(...read.value.items);
-        // An org that reports another page but no usable cursor can't be resumed: it would neither be
-        // recorded in the composite cursor nor marked exhausted, so the next round would re-read its
-        // page 1 and repeat every issue. Treat it as terminal-but-incomplete (which also marks the org
-        // exhausted below, since `exhausted` keys off `!hasMore`).
-        const continuation = resolveContinuation(read.value, undefined);
-        hasMore = continuation.hasMore;
-        nextCursor = continuation.cursor;
-        issuesTruncated = continuation.truncated;
-    }
-    else if (read.warning != null || cursor != null) {
-        // Keep the exact position that failed. Without this retry cursor a multi-org continuation would
-        // omit this org from the bundle, then synthesize the next numbered page and silently skip the
-        // failed page. The synthesized page cursor is also actionable for a first-page cursor-only read:
-        // that provider ignores the page marker and retries its first page. A retry slot alone is NOT
-        // forward progress, though: advertising `hasMore` for a persistent failure would make an infinite
-        // query request it forever. Healthy sibling continuations set `hasMore` independently.
-        if (cursor != null) {
-            nextCursor = cursor;
-            if (read.warning == null) {
-                appendDedupedWarning(warnings, otherWarning(org.providerId, domain, connectionId, 'Issue continuation returned no result and must be retried'));
-                issuesFetchFailed = true;
-                issuesTruncated = true;
-            }
-        }
-        else {
-            retryPage = page;
-        }
-    }
-    return {
-        items: items,
-        warnings: warnings,
-        broadenedProviderIds: read.value != null ? [org.providerId] : [],
-        providerId: org.providerId,
-        org: org.name,
-        connectionId: connectionId,
-        domain: cursorDomain,
-        nextCursor: nextCursor,
-        retryPage: retryPage,
-        hasMore: hasMore,
-        // Exhausted once a successful read reports no more pages — recorded in the cursor so later
-        // rounds skip it while other orgs keep paging.
-        exhausted: read.value != null && !hasMore,
-        fetchFailed: issuesFetchFailed,
-        truncated: read.truncated || issuesTruncated,
-    };
+	const connectionId = org.connectionId;
+	const requestedDomain = org.domain;
+	const cursorDomain = hostFromDomain(requestedDomain) ?? requestedDomain;
+	const barrenSlice = (warnings, flags) => ({
+		items: [],
+		warnings,
+		broadenedProviderIds: [],
+		providerId: org.providerId,
+		org: org.name,
+		connectionId,
+		domain: cursorDomain,
+		nextCursor: void 0,
+		hasMore: false,
+		exhausted: flags?.exhausted ?? false,
+		fetchFailed: flags?.fetchFailed ?? false,
+		truncated: flags?.truncated ?? false
+	});
+	if (isIssuesHostIntegrationId(org.providerId)) return barrenSlice([gitHostOnlySurfaceWarning(org.providerId, requestedDomain, connectionId, "issue broadening")], { fetchFailed: true });
+	const integration = await ctx.getIntegrationForRead(org.providerId, connectionId, requestedDomain);
+	if (integration == null) {
+		const early = ctx.earlyReturnConnectionWarnings(org.providerId, connectionId, requestedDomain);
+		return barrenSlice(early.warnings.length > 0 ? early.warnings : [noConnectionWarning(org.providerId, requestedDomain, connectionId)], { fetchFailed: true });
+	}
+	if (!isGitHostIntegration(integration)) return barrenSlice([gitHostOnlySurfaceWarning(org.providerId, requestedDomain, connectionId, "issue broadening")], { fetchFailed: true });
+	if (!integration.supportsIssues) return barrenSlice([issuesUnsupportedWarning(org.providerId, ctx.domainForRead(integration, org.providerId, connectionId, requestedDomain), connectionId)], { fetchFailed: true });
+	const scopeRejection = resolveIssueSearchScope(void 0, org.name, void 0).rejection;
+	if (scopeRejection != null) return barrenSlice([otherWarning(org.providerId, ctx.domainForRead(integration, org.providerId, connectionId, requestedDomain), connectionId, scopeRejection.reason === "unusable-scope" ? unusableSearchScopeMessage("issue broadening scopes", scopeRejection.scopes) : "Issue broadening must name an organization; one was supplied with an empty name.")], { fetchFailed: true });
+	if (isBroadenIssuesOrgExhausted(options.cursor, org, options.orgs.length)) return barrenSlice([], { exhausted: true });
+	await ctx.forceRefreshIfRequested(integration, options.forceSync, connectionId);
+	const domain = ctx.domainForRead(integration, org.providerId, connectionId, requestedDomain);
+	const cursor = getBroadenIssuesCursor(options.cursor, org, page, options.orgs.length);
+	const read = supportsFilteredIssueSearch(org.providerId) ? await readOrgIssuesViaSearch(integration, org, domain, cursor) : await readOrgIssuesViaRepoDrain(integration, org, domain, cursor);
+	if (read.nothingToRead === true) return barrenSlice(read.warnings, {
+		fetchFailed: read.fetchFailed,
+		truncated: read.truncated
+	});
+	const warnings = read.warnings;
+	let issuesFetchFailed = read.fetchFailed || read.warning != null && read.value == null;
+	const items = [];
+	let hasMore = false;
+	let nextCursor;
+	let retryPage;
+	let issuesTruncated = false;
+	if (read.value != null) {
+		items.push(...read.value.items);
+		const continuation = resolveContinuation(read.value, void 0);
+		hasMore = continuation.hasMore;
+		nextCursor = continuation.cursor;
+		issuesTruncated = continuation.truncated;
+	} else if (read.warning != null || cursor != null) {
+		if (cursor != null) {
+			nextCursor = cursor;
+			if (read.warning == null) {
+				appendDedupedWarning(warnings, otherWarning(org.providerId, domain, connectionId, "Issue continuation returned no result and must be retried"));
+				issuesFetchFailed = true;
+				issuesTruncated = true;
+			}
+		} else retryPage = page;
+	}
+	return {
+		items,
+		warnings,
+		broadenedProviderIds: read.value != null ? [org.providerId] : [],
+		providerId: org.providerId,
+		org: org.name,
+		connectionId,
+		domain: cursorDomain,
+		nextCursor,
+		retryPage,
+		hasMore,
+		exhausted: read.value != null && !hasMore,
+		fetchFailed: issuesFetchFailed,
+		truncated: read.truncated || issuesTruncated
+	};
 }
+//#endregion
+export { broadenIssues };
+
 //# sourceMappingURL=broaden.js.map