@gitkraken/core-gitlens 0.5.116 → 0.7.0

package/dist/git/gitHealth.js

@@ -1,353 +1,283 @@
+import * as l10n from "@vscode/l10n";
+//#region ../git/src/gitHealth.ts
 /**
- * Pure recommendation engine for the Git Health feature — no vscode imports, trivially unit-testable.
- * Thresholds are initial, tunable, telemetry-informed values (see `.work/dev/git-health/spec.md`).
- */
+* Pure recommendation engine for the Git Health feature — no vscode imports, trivially unit-testable.
+* Thresholds are initial, tunable, telemetry-informed values (see `.work/dev/git-health/spec.md`).
+*/
 /** Working-tree size (via the index-bytes proxy) at/above which untracked-cache/fsmonitor/manyFiles help. */
-export const trackedFilesThreshold = 10_000;
+const trackedFilesThreshold = 1e4;
 /** Loose-object estimate at/above which the `loose-objects` maintenance task is worth running. */
-export const looseObjectsThreshold = 5_000;
+const looseObjectsThreshold = 5e3;
 /** Git's default uncovered-pack threshold for the `incremental-repack` auto condition. */
-export const packsOutsideMultiPackIndexThreshold = 10;
+const packsOutsideMultiPackIndexThreshold = 10;
 /** Loose refs at/above which packing the files ref backend avoids repeated filesystem traversal. */
-export const looseRefsThreshold = 256;
+const looseRefsThreshold = 256;
 /** Total pack bytes at/above which a repo counts as "clearly large" for the banner gate (~1 GiB). */
-export const largePackBytesThreshold = 1024 ** 3;
+const largePackBytesThreshold = 1024 ** 3;
 /** Rough bytes-per-entry of a git v2 index — turns `.git/index` size into a tracked-file-count proxy. */
-export const approxBytesPerIndexEntry = 80;
+const approxBytesPerIndexEntry = 80;
 /** Duration (ms) above which a git command is "slow" — mirrors the exec-layer slow-call threshold. */
-export const slowCommandThresholdMs = 2000;
+const slowCommandThresholdMs = 2e3;
 /**
- * Extrapolates total loose-object count from a uniform sample of the 256 object fanout dirs. Loose
- * objects distribute uniformly by sha prefix, so `(objectsInSampled / dirsSampled) * 256` is sound.
- */
-export function estimateLooseObjects(objectsInSampled, dirsSampled) {
-    if (dirsSampled <= 0)
-        return 0;
-    return Math.round((objectsInSampled / dirsSampled) * 256);
+* Extrapolates total loose-object count from a uniform sample of the 256 object fanout dirs. Loose
+* objects distribute uniformly by sha prefix, so `(objectsInSampled / dirsSampled) * 256` is sound.
+*/
+function estimateLooseObjects(objectsInSampled, dirsSampled) {
+	if (dirsSampled <= 0) return 0;
+	return Math.round(objectsInSampled / dirsSampled * 256);
 }
 /** Turns `.git/index` byte size into an approximate tracked-file count. */
-export function estimateTrackedFiles(indexBytes) {
-    if (indexBytes <= 0)
-        return 0;
-    return Math.round(indexBytes / approxBytesPerIndexEntry);
+function estimateTrackedFiles(indexBytes) {
+	if (indexBytes <= 0) return 0;
+	return Math.round(indexBytes / 80);
 }
 /**
- * Computes the {@link GitHealthReport} from a cheap probe, passive slowness, and capabilities. Findings
- * are only emitted for levers that are supported, not already applied, and past their threshold.
- */
-export function computeHealthReport(snapshot, slowness, capabilities) {
-    const estimatedLooseObjects = estimateLooseObjects(snapshot.looseObjects.objectsInSampledDirs, snapshot.looseObjects.dirsSampled);
-    // A normal index header is the exact tracked-file count. A sparse index header is still a useful exact
-    // count of its populated working set, but not of the whole repository. A split index header covers only
-    // the mutable layer and conflict stages duplicate paths, so neither raw count is used.
-    const useIndexEntryCount = snapshot.indexEntryCount != null &&
-        (snapshot.indexEntryCountType === 'full' || snapshot.indexEntryCountType === 'sparse');
-    const estimatedTrackedFiles = useIndexEntryCount
-        ? snapshot.indexEntryCount
-        : estimateTrackedFiles(snapshot.indexBytes);
-    const trackedFilesExact = useIndexEntryCount && snapshot.indexEntryCountType === 'full';
-    const trackedFilesScope = trackedFilesExact
-        ? 'repository'
-        : useIndexEntryCount && snapshot.indexEntryCountType === 'sparse'
-            ? 'sparseWorkingTree'
-            : 'estimate';
-    const largeWorkingTree = estimatedTrackedFiles >= trackedFilesThreshold;
-    const clearlyLarge = largeWorkingTree || snapshot.packBytes >= largePackBytesThreshold;
-    const supported = (id) => capabilities.find(c => c.id === id)?.supported === true;
-    const findings = [];
-    // Auto tier — safe `git maintenance run` one-shots (gated on `git maintenance` support).
-    if (snapshot.supportsMaintenanceRun) {
-        if (estimatedLooseObjects >= looseObjectsThreshold) {
-            findings.push({
-                tier: 'auto',
-                reason: 'looseObjects',
-                value: estimatedLooseObjects,
-                threshold: looseObjectsThreshold,
-                action: { kind: 'maintenance', task: 'loose-objects' },
-            });
-        }
-        const incrementalRepackThreshold = snapshot.incrementalRepackAutoThreshold;
-        const incrementalRepackDue = snapshot.multiPackIndexEnabled === true &&
-            snapshot.packsOutsideMultiPackIndex != null &&
-            incrementalRepackThreshold != null &&
-            incrementalRepackThreshold !== 0 &&
-            (incrementalRepackThreshold < 0
-                ? snapshot.packCount > 0
-                : snapshot.packsOutsideMultiPackIndex >= incrementalRepackThreshold);
-        if (incrementalRepackDue) {
-            findings.push({
-                tier: 'auto',
-                reason: 'packsOutsideMultiPackIndex',
-                value: snapshot.packsOutsideMultiPackIndex,
-                threshold: incrementalRepackThreshold,
-                action: { kind: 'maintenance', task: 'incremental-repack' },
-            });
-        }
-    }
-    if (snapshot.supportsPackRefsMaintenance &&
-        snapshot.repository.refFormat === 'files' &&
-        snapshot.looseRefs.count >= looseRefsThreshold) {
-        findings.push({
-            tier: 'auto',
-            reason: 'looseRefs',
-            value: snapshot.looseRefs.count,
-            threshold: looseRefsThreshold,
-            action: { kind: 'maintenance', task: 'pack-refs' },
-        });
-    }
-    // Large-working-tree levers share the same evidence; they differ only in tier and eligibility.
-    const trackedFilesEvidence = {
-        reason: 'trackedFiles',
-        value: estimatedTrackedFiles,
-        threshold: trackedFilesThreshold,
-    };
-    const workingTreeLevers = [
-        {
-            id: 'untrackedCache',
-            tier: 'ask',
-            // Skip if already on, if it previously failed git's filesystem probe for this repo, or if the
-            // user set the key themselves — an explicit `false`/`keep` is a decision (often made after bad
-            // `git status` results), and this lever respects it rather than overriding it.
-            eligible: !snapshot.config.untrackedCache &&
-                !snapshot.config.untrackedCacheConfigured &&
-                !snapshot.untrackedCacheNotApplicable,
-        },
-        {
-            id: 'fsmonitor',
-            tier: 'ask',
-            // Skip if already on or it previously failed to start for this repo.
-            eligible: !snapshot.config.fsmonitor && !snapshot.fsmonitorNotApplicable,
-        },
-        {
-            id: 'manyFiles',
-            tier: 'ask',
-            // `manyFiles` defaults the untracked cache on, so a repo whose filesystem already failed that
-            // probe must not be offered it either — unless the user's own explicit `core.untrackedCache`
-            // setting overrides the default, in which case the probe result is moot.
-            eligible: !snapshot.config.manyFiles &&
-                !(snapshot.untrackedCacheNotApplicable && !snapshot.config.untrackedCacheConfigured),
-        },
-        {
-            id: 'sparseIndex',
-            tier: 'ask',
-            // Sparse-directory entries are safe only in cone mode. Require a normal full index so this
-            // recommendation is based on the repository-wide path count, not a split/conflicted approximation.
-            eligible: snapshot.repository.sparseCheckout === true &&
-                snapshot.repository.sparseCheckoutCone === true &&
-                snapshot.repository.sparseIndex === false &&
-                snapshot.repository.splitIndex === false &&
-                snapshot.indexEntryCountType === 'full',
-        },
-    ];
-    const worktreeSlowness = slowness?.worktree;
-    const worktreeSlownessObserved = (worktreeSlowness?.count ?? 0) > 0;
-    if (largeWorkingTree || worktreeSlownessObserved) {
-        const evidence = largeWorkingTree
-            ? trackedFilesEvidence
-            : {
-                reason: 'worktreeSlowness',
-                value: worktreeSlowness?.maxDurationMs ?? 0,
-                threshold: slowCommandThresholdMs,
-            };
-        for (const lever of workingTreeLevers) {
-            if (!lever.eligible || !supported(lever.id))
-                continue;
-            findings.push({
-                tier: lever.tier,
-                ...evidence,
-                action: { kind: 'optimization', id: lever.id },
-            });
-        }
-    }
-    // Ask tier — system-scheduled background maintenance. Suggested for a not-yet-registered repo that's
-    // clearly large. Passive slowness is deliberately NOT enough: worktree slowness maps to the worktree
-    // levers above, history is already covered by demand commit-graph writes, and ref/object maintenance has
-    // its own measured auto-tier conditions. A generic scheduler recommendation would promise the wrong fix.
-    // `=== false`, not falsy: `undefined` means the registration list couldn't be read, and an unknown state
-    // must never be suggested away — that's how a user's own registration gets silently reclaimed by Undo.
-    if (clearlyLarge && snapshot.maintenanceRegistered === false && supported('backgroundMaintenance')) {
-        // Resolve the evidence once so reason/value/threshold can never drift apart. Ordered so each
-        // suggestion argues from its most DISTINCTIVE signal rather than whichever crossed first: a repo
-        // large by both file count and pack bytes would otherwise attach the same tracked-files evidence to
-        // this finding as to the fsmonitor/manyFiles findings, and the view would show two identical meters.
-        let evidence;
-        if (snapshot.packBytes >= largePackBytesThreshold) {
-            evidence = { reason: 'largePacks', value: snapshot.packBytes, threshold: largePackBytesThreshold };
-        }
-        else {
-            evidence = trackedFilesEvidence;
-        }
-        findings.push({
-            tier: 'ask',
-            ...evidence,
-            action: { kind: 'optimization', id: 'backgroundMaintenance' },
-        });
-    }
-    return {
-        findings: findings,
-        repository: snapshot.repository,
-        clearlyLarge: clearlyLarge,
-        estimatedLooseObjects: estimatedLooseObjects,
-        looseRefs: snapshot.looseRefs,
-        estimatedTrackedFiles: estimatedTrackedFiles,
-        trackedFilesExact: trackedFilesExact,
-        trackedFilesScope: trackedFilesScope,
-        packCount: snapshot.packCount,
-        packsOutsideMultiPackIndex: snapshot.packsOutsideMultiPackIndex,
-        packBytes: snapshot.packBytes,
-        commitGraph: snapshot.commitGraph,
-    };
+* Computes the {@link GitHealthReport} from a cheap probe, passive slowness, and capabilities. Findings
+* are only emitted for levers that are supported, not already applied, and past their threshold.
+*/
+function computeHealthReport(snapshot, slowness, capabilities) {
+	const estimatedLooseObjects = estimateLooseObjects(snapshot.looseObjects.objectsInSampledDirs, snapshot.looseObjects.dirsSampled);
+	const useIndexEntryCount = snapshot.indexEntryCount != null && (snapshot.indexEntryCountType === "full" || snapshot.indexEntryCountType === "sparse");
+	const estimatedTrackedFiles = useIndexEntryCount ? snapshot.indexEntryCount : estimateTrackedFiles(snapshot.indexBytes);
+	const trackedFilesExact = useIndexEntryCount && snapshot.indexEntryCountType === "full";
+	const trackedFilesScope = trackedFilesExact ? "repository" : useIndexEntryCount && snapshot.indexEntryCountType === "sparse" ? "sparseWorkingTree" : "estimate";
+	const largeWorkingTree = estimatedTrackedFiles >= trackedFilesThreshold;
+	const clearlyLarge = largeWorkingTree || snapshot.packBytes >= largePackBytesThreshold;
+	const supported = (id) => capabilities.find((c) => c.id === id)?.supported === true;
+	const findings = [];
+	if (snapshot.supportsMaintenanceRun) {
+		if (estimatedLooseObjects >= 5e3) findings.push({
+			tier: "auto",
+			reason: "looseObjects",
+			value: estimatedLooseObjects,
+			threshold: looseObjectsThreshold,
+			action: {
+				kind: "maintenance",
+				task: "loose-objects"
+			}
+		});
+		const incrementalRepackThreshold = snapshot.incrementalRepackAutoThreshold;
+		if (snapshot.multiPackIndexEnabled === true && snapshot.packsOutsideMultiPackIndex != null && incrementalRepackThreshold != null && incrementalRepackThreshold !== 0 && (incrementalRepackThreshold < 0 ? snapshot.packCount > 0 : snapshot.packsOutsideMultiPackIndex >= incrementalRepackThreshold)) findings.push({
+			tier: "auto",
+			reason: "packsOutsideMultiPackIndex",
+			value: snapshot.packsOutsideMultiPackIndex,
+			threshold: incrementalRepackThreshold,
+			action: {
+				kind: "maintenance",
+				task: "incremental-repack"
+			}
+		});
+	}
+	if (snapshot.supportsPackRefsMaintenance && snapshot.repository.refFormat === "files" && snapshot.looseRefs.count >= 256) findings.push({
+		tier: "auto",
+		reason: "looseRefs",
+		value: snapshot.looseRefs.count,
+		threshold: 256,
+		action: {
+			kind: "maintenance",
+			task: "pack-refs"
+		}
+	});
+	const trackedFilesEvidence = {
+		reason: "trackedFiles",
+		value: estimatedTrackedFiles,
+		threshold: trackedFilesThreshold
+	};
+	const workingTreeLevers = [
+		{
+			id: "untrackedCache",
+			tier: "ask",
+			eligible: !snapshot.config.untrackedCache && !snapshot.config.untrackedCacheConfigured && !snapshot.untrackedCacheNotApplicable
+		},
+		{
+			id: "fsmonitor",
+			tier: "ask",
+			eligible: !snapshot.config.fsmonitor && !snapshot.fsmonitorNotApplicable
+		},
+		{
+			id: "manyFiles",
+			tier: "ask",
+			eligible: !snapshot.config.manyFiles && !(snapshot.untrackedCacheNotApplicable && !snapshot.config.untrackedCacheConfigured)
+		},
+		{
+			id: "sparseIndex",
+			tier: "ask",
+			eligible: snapshot.repository.sparseCheckout === true && snapshot.repository.sparseCheckoutCone === true && snapshot.repository.sparseIndex === false && snapshot.repository.splitIndex === false && snapshot.indexEntryCountType === "full"
+		}
+	];
+	const worktreeSlowness = slowness?.worktree;
+	const worktreeSlownessObserved = (worktreeSlowness?.count ?? 0) > 0;
+	if (largeWorkingTree || worktreeSlownessObserved) {
+		const evidence = largeWorkingTree ? trackedFilesEvidence : {
+			reason: "worktreeSlowness",
+			value: worktreeSlowness?.maxDurationMs ?? 0,
+			threshold: slowCommandThresholdMs
+		};
+		for (const lever of workingTreeLevers) {
+			if (!lever.eligible || !supported(lever.id)) continue;
+			findings.push({
+				tier: lever.tier,
+				...evidence,
+				action: {
+					kind: "optimization",
+					id: lever.id
+				}
+			});
+		}
+	}
+	if (clearlyLarge && snapshot.maintenanceRegistered === false && supported("backgroundMaintenance")) {
+		let evidence;
+		if (snapshot.packBytes >= largePackBytesThreshold) evidence = {
+			reason: "largePacks",
+			value: snapshot.packBytes,
+			threshold: largePackBytesThreshold
+		};
+		else evidence = trackedFilesEvidence;
+		findings.push({
+			tier: "ask",
+			...evidence,
+			action: {
+				kind: "optimization",
+				id: "backgroundMaintenance"
+			}
+		});
+	}
+	return {
+		findings,
+		repository: snapshot.repository,
+		clearlyLarge,
+		estimatedLooseObjects,
+		looseRefs: snapshot.looseRefs,
+		estimatedTrackedFiles,
+		trackedFilesExact,
+		trackedFilesScope,
+		packCount: snapshot.packCount,
+		packsOutsideMultiPackIndex: snapshot.packsOutsideMultiPackIndex,
+		packBytes: snapshot.packBytes,
+		commitGraph: snapshot.commitGraph
+	};
 }
 /** Consequences that reach beyond GitLens, surfaced on the apply action itself. */
-const leverNotes = {
-    backgroundMaintenance: 'Adds a task to your operating system’s scheduler. Undo unregisters this repository, but leaves the scheduler itself in place.',
-};
+const leverNotes = { backgroundMaintenance: l10n.t("Adds a task to your operating system’s scheduler. Undo unregisters this repository, but leaves the scheduler itself in place.") };
 /**
- * Collapses a snapshot + capabilities + report into the per-lever rows the Git Health view renders.
- * Pure, so the webview never re-derives ownership or eligibility rules that already live here.
- */
-export function computeLevers(snapshot, capabilities, report) {
-    const suggested = new Set(report.findings.flatMap(f => (f.action.kind === 'optimization' ? [f.action.id] : [])));
-    const enabled = {
-        untrackedCache: snapshot.config.untrackedCache,
-        fsmonitor: snapshot.config.fsmonitor,
-        manyFiles: snapshot.config.manyFiles,
-        // `=== true`, not the raw (possibly `undefined`) value — an unreadable registration is handled as its
-        // own status below, and must never fall through to "enabled".
-        backgroundMaintenance: snapshot.maintenanceRegistered === true,
-        sparseIndex: snapshot.repository.sparseIndex === true,
-    };
-    const blocked = {
-        untrackedCache: snapshot.untrackedCacheNotApplicable,
-        fsmonitor: snapshot.fsmonitorNotApplicable,
-        manyFiles: snapshot.untrackedCacheNotApplicable && !snapshot.config.untrackedCacheConfigured,
-    };
-    return capabilities.map(capability => {
-        const id = capability.id;
-        const note = capability.note ?? leverNotes[id];
-        // Every optimization lever is ask-tier now — the auto tier only ever runs maintenance tasks.
-        const tier = 'ask';
-        // Unavailable outranks everything: a lever the installed git or platform cannot do is never
-        // "suggested", whatever the thresholds say.
-        if (!capability.supported) {
-            return { id: id, status: 'unavailable', tier: tier, reason: capability.reason, note: note };
-        }
-        // An unreadable maintenance registration can't answer the ownership/suggestion questions below, so
-        // it gets its own status rather than falling through and being guessed as "not registered".
-        if (id === 'backgroundMaintenance' && snapshot.maintenanceRegistered === undefined) {
-            return {
-                id: id,
-                status: 'unavailable',
-                tier: tier,
-                reason: "Couldn't read Git's maintenance registration — try reopening the repository",
-                note: note,
-                checkFailed: true,
-            };
-        }
-        // Then ownership, which is what decides whether Undo is offered at all.
-        if (enabled[id]) {
-            return { id: id, status: snapshot.applied[id] ? 'applied' : 'userEnabled', tier: tier, note: note };
-        }
-        if (id === 'sparseIndex') {
-            if (snapshot.repository.sparseCheckout == null ||
-                snapshot.repository.sparseCheckoutCone == null ||
-                snapshot.repository.sparseIndex == null ||
-                snapshot.repository.splitIndex == null) {
-                return {
-                    id: id,
-                    status: 'unavailable',
-                    tier: tier,
-                    reason: "Couldn't determine this worktree’s sparse-checkout and index configuration",
-                    note: note,
-                    checkFailed: true,
-                };
-            }
-            if (!snapshot.repository.sparseCheckout) {
-                return {
-                    id: id,
-                    status: 'notApplicable',
-                    tier: tier,
-                    reason: 'This worktree is not using sparse checkout.',
-                    note: note,
-                };
-            }
-            if (!snapshot.repository.sparseCheckoutCone) {
-                return {
-                    id: id,
-                    status: 'notApplicable',
-                    tier: tier,
-                    reason: 'Sparse indexes require cone-mode sparse checkout.',
-                    note: note,
-                };
-            }
-            if (snapshot.repository.splitIndex || snapshot.indexEntryCountType === 'split') {
-                return {
-                    id: id,
-                    status: 'notApplicable',
-                    tier: tier,
-                    reason: 'This worktree uses a split index; disable it before enabling a sparse index.',
-                    note: note,
-                };
-            }
-            if (snapshot.indexEntryCountType === 'conflicted') {
-                return {
-                    id: id,
-                    status: 'notApplicable',
-                    tier: tier,
-                    reason: 'Finish the current merge or rebase before enabling a sparse index.',
-                    note: note,
-                };
-            }
-        }
-        // `notApplicable` means GitLens TRIED here and this repo can't use it — the gk marker records that.
-        // `capability.note` is the supported-with-caveat field, not an unavailability reason, so the
-        // explanation has to come from the marker's meaning instead.
-        if (blocked[id]) {
-            return {
-                id: id,
-                status: 'notApplicable',
-                tier: tier,
-                reason: id === 'fsmonitor'
-                    ? 'The file system monitor could not start for this repository.'
-                    : id === 'manyFiles'
-                        ? 'This would enable the untracked cache, but this file system does not report directory changes reliably, so Git would return incorrect status results.'
-                        : 'This file system does not report directory changes reliably, so Git would return incorrect status results.',
-                note: note,
-            };
-        }
-        // Supported and usable, just below the thresholds — `available`, never `notApplicable`. Reporting
-        // a healthy repo's levers as unavailable tells the user something false.
-        return { id: id, status: suggested.has(id) ? 'suggested' : 'available', tier: tier, note: note };
-    });
+* Collapses a snapshot + capabilities + report into the per-lever rows the Git Health view renders.
+* Pure, so the webview never re-derives ownership or eligibility rules that already live here.
+*/
+function computeLevers(snapshot, capabilities, report) {
+	const suggested = new Set(report.findings.flatMap((f) => f.action.kind === "optimization" ? [f.action.id] : []));
+	const enabled = {
+		untrackedCache: snapshot.config.untrackedCache,
+		fsmonitor: snapshot.config.fsmonitor,
+		manyFiles: snapshot.config.manyFiles,
+		backgroundMaintenance: snapshot.maintenanceRegistered === true,
+		sparseIndex: snapshot.repository.sparseIndex === true
+	};
+	const blocked = {
+		untrackedCache: snapshot.untrackedCacheNotApplicable,
+		fsmonitor: snapshot.fsmonitorNotApplicable,
+		manyFiles: snapshot.untrackedCacheNotApplicable && !snapshot.config.untrackedCacheConfigured
+	};
+	return capabilities.map((capability) => {
+		const id = capability.id;
+		const note = capability.note ?? leverNotes[id];
+		const tier = "ask";
+		if (!capability.supported) return {
+			id,
+			status: "unavailable",
+			tier,
+			reason: capability.reason,
+			note
+		};
+		if (id === "backgroundMaintenance" && snapshot.maintenanceRegistered === void 0) return {
+			id,
+			status: "unavailable",
+			tier,
+			reason: l10n.t("Couldn't read Git's maintenance registration — try reopening the repository"),
+			note,
+			checkFailed: true
+		};
+		if (enabled[id]) return {
+			id,
+			status: snapshot.applied[id] ? "applied" : "userEnabled",
+			tier,
+			note
+		};
+		if (id === "sparseIndex") {
+			if (snapshot.repository.sparseCheckout == null || snapshot.repository.sparseCheckoutCone == null || snapshot.repository.sparseIndex == null || snapshot.repository.splitIndex == null) return {
+				id,
+				status: "unavailable",
+				tier,
+				reason: l10n.t("Couldn't determine this worktree’s sparse-checkout and index configuration"),
+				note,
+				checkFailed: true
+			};
+			if (!snapshot.repository.sparseCheckout) return {
+				id,
+				status: "notApplicable",
+				tier,
+				reason: l10n.t("This worktree is not using sparse checkout."),
+				note
+			};
+			if (!snapshot.repository.sparseCheckoutCone) return {
+				id,
+				status: "notApplicable",
+				tier,
+				reason: l10n.t("Sparse indexes require cone-mode sparse checkout."),
+				note
+			};
+			if (snapshot.repository.splitIndex || snapshot.indexEntryCountType === "split") return {
+				id,
+				status: "notApplicable",
+				tier,
+				reason: l10n.t("This worktree uses a split index; disable it before enabling a sparse index."),
+				note
+			};
+			if (snapshot.indexEntryCountType === "conflicted") return {
+				id,
+				status: "notApplicable",
+				tier,
+				reason: l10n.t("Finish the current merge or rebase before enabling a sparse index."),
+				note
+			};
+		}
+		if (blocked[id]) return {
+			id,
+			status: "notApplicable",
+			tier,
+			reason: id === "fsmonitor" ? l10n.t("The file system monitor could not start for this repository.") : id === "manyFiles" ? l10n.t("This would enable the untracked cache, but this file system does not report directory changes reliably, so Git would return incorrect status results.") : l10n.t("This file system does not report directory changes reliably, so Git would return incorrect status results."),
+			note
+		};
+		return {
+			id,
+			status: suggested.has(id) ? "suggested" : "available",
+			tier,
+			note
+		};
+	});
 }
 /** Auto-tier maintenance tasks the daily pass should run right now (deduped, order-stable). */
-export function getAutoMaintenanceTasks(report) {
-    const tasks = [];
-    for (const finding of report.findings) {
-        if (finding.tier === 'auto' && finding.action.kind === 'maintenance' && !tasks.includes(finding.action.task)) {
-            tasks.push(finding.action.task);
-        }
-    }
-    return tasks;
+function getAutoMaintenanceTasks(report) {
+	const tasks = [];
+	for (const finding of report.findings) if (finding.tier === "auto" && finding.action.kind === "maintenance" && !tasks.includes(finding.action.task)) tasks.push(finding.action.task);
+	return tasks;
 }
 /** Auto-tier optimization levers the daily pass should silently apply — none today; the auto tier currently
- * applies only maintenance tasks, but this stays in place for future levers. */
-export function getAutoOptimizations(report) {
-    const ids = [];
-    for (const finding of report.findings) {
-        if (finding.tier === 'auto' && finding.action.kind === 'optimization' && !ids.includes(finding.action.id)) {
-            ids.push(finding.action.id);
-        }
-    }
-    return ids;
+* applies only maintenance tasks, but this stays in place for future levers. */
+function getAutoOptimizations(report) {
+	const ids = [];
+	for (const finding of report.findings) if (finding.tier === "auto" && finding.action.kind === "optimization" && !ids.includes(finding.action.id)) ids.push(finding.action.id);
+	return ids;
 }
 /**
- * Banner rule: fire only when the report contains an ask-tier fix and the repo is clearly large or slow in
- * the working-tree family. History/ref/object slowness must not advertise unrelated worktree levers.
- */
-export function isBannerEligible(report, slowness) {
-    const hasAskTierFix = report.findings.some(f => f.tier === 'ask');
-    const worktreeSlownessObserved = (slowness?.worktree?.count ?? 0) > 0;
-    return hasAskTierFix && (report.clearlyLarge || worktreeSlownessObserved);
+* Banner rule: fire only when the report contains an ask-tier fix and the repo is clearly large or slow in
+* the working-tree family. History/ref/object slowness must not advertise unrelated worktree levers.
+*/
+function isBannerEligible(report, slowness) {
+	const hasAskTierFix = report.findings.some((f) => f.tier === "ask");
+	const worktreeSlownessObserved = (slowness?.worktree?.count ?? 0) > 0;
+	return hasAskTierFix && (report.clearlyLarge || worktreeSlownessObserved);
 }
+//#endregion
+export { approxBytesPerIndexEntry, computeHealthReport, computeLevers, estimateLooseObjects, estimateTrackedFiles, getAutoMaintenanceTasks, getAutoOptimizations, isBannerEligible, largePackBytesThreshold, looseObjectsThreshold, looseRefsThreshold, packsOutsideMultiPackIndexThreshold, slowCommandThresholdMs, trackedFilesThreshold };
+
 //# sourceMappingURL=gitHealth.js.map