@eduardbar/drift 1.3.0 → 1.4.0

package/dist/trust-kpi.js

@@ -1,10 +1,6 @@
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
-import { dirname, isAbsolute, resolve } from 'node:path';
-import { MERGE_RISK_ORDER, normalizeMergeRiskLevel } from './trust.js';
-const IGNORED_DIRECTORIES = new Set(['node_modules', '.git', 'dist', '.next', 'build']);
-function toPosixPath(path) {
-    return path.replace(/\\/g, '/');
-}
+import { normalizeMergeRiskLevel } from './trust.js';
+import { discoverTrustJsonFiles } from './trust-kpi-fs.js';
+import { parseTrustArtifact } from './trust-kpi-parse.js';
 function round(value, decimals = 2) {
     return Number(value.toFixed(decimals));
 }
@@ -23,263 +19,6 @@ function average(values) {
         return null;
     return round(values.reduce((sum, value) => sum + value, 0) / values.length);
 }
-function listFilesRecursively(root) {
-    if (!existsSync(root))
-        return [];
-    const out = [];
-    const stack = [root];
-    while (stack.length > 0) {
-        const current = stack.pop();
-        for (const entry of readdirSync(current)) {
-            const fullPath = resolve(current, entry);
-            const info = statSync(fullPath);
-            if (info.isDirectory()) {
-                if (IGNORED_DIRECTORIES.has(entry))
-                    continue;
-                stack.push(fullPath);
-            }
-            else {
-                out.push(fullPath);
-            }
-        }
-    }
-    return out;
-}
-function isGlobPattern(input) {
-    return /[*?[\]{}]/.test(input);
-}
-function escapeRegex(char) {
-    return /[\\^$+?.()|{}\[\]]/.test(char) ? `\\${char}` : char;
-}
-function globToRegex(pattern) {
-    const normalized = toPosixPath(pattern);
-    let expression = '^';
-    for (let index = 0; index < normalized.length; index += 1) {
-        const char = normalized[index];
-        const nextChar = normalized[index + 1];
-        const nextNextChar = normalized[index + 2];
-        if (char === '*' && nextChar === '*') {
-            if (nextNextChar === '/') {
-                expression += '(?:.*/)?';
-                index += 2;
-                continue;
-            }
-            expression += '.*';
-            index += 1;
-            continue;
-        }
-        if (char === '*') {
-            expression += '[^/]*';
-            continue;
-        }
-        if (char === '?') {
-            expression += '[^/]';
-            continue;
-        }
-        expression += escapeRegex(char);
-    }
-    expression += '$';
-    return new RegExp(expression);
-}
-function globBaseDir(pattern) {
-    const normalized = toPosixPath(pattern);
-    const wildcardIndex = normalized.search(/[*?[\]{}]/);
-    if (wildcardIndex < 0)
-        return dirname(pattern);
-    const prefix = normalized.slice(0, wildcardIndex);
-    const slashIndex = prefix.lastIndexOf('/');
-    if (slashIndex < 0)
-        return '.';
-    if (slashIndex === 0)
-        return '/';
-    return prefix.slice(0, slashIndex);
-}
-function discoverTrustJsonFiles(input, cwd) {
-    const diagnostics = [];
-    const source = input.trim() || '.';
-    if (isGlobPattern(source)) {
-        const absolutePattern = isAbsolute(source) ? source : resolve(cwd, source);
-        const regex = globToRegex(toPosixPath(absolutePattern));
-        const base = resolve(cwd, globBaseDir(source));
-        if (!existsSync(base)) {
-            diagnostics.push({
-                level: 'error',
-                code: 'path-not-found',
-                message: `Glob base path does not exist: ${base}`,
-            });
-            return { files: [], diagnostics };
-        }
-        const matched = listFilesRecursively(base)
-            .filter((filePath) => regex.test(toPosixPath(filePath)))
-            .filter((filePath) => filePath.toLowerCase().endsWith('.json'))
-            .sort((a, b) => a.localeCompare(b));
-        return { files: matched, diagnostics };
-    }
-    const absolute = isAbsolute(source) ? source : resolve(cwd, source);
-    if (!existsSync(absolute)) {
-        diagnostics.push({
-            level: 'error',
-            code: 'path-not-found',
-            message: `Path does not exist: ${absolute}`,
-        });
-        return { files: [], diagnostics };
-    }
-    const info = statSync(absolute);
-    if (info.isDirectory()) {
-        const files = listFilesRecursively(absolute)
-            .filter((filePath) => filePath.toLowerCase().endsWith('.json'))
-            .sort((a, b) => a.localeCompare(b));
-        return { files, diagnostics };
-    }
-    if (info.isFile()) {
-        if (!absolute.toLowerCase().endsWith('.json')) {
-            diagnostics.push({
-                level: 'warning',
-                code: 'path-not-supported',
-                file: absolute,
-                message: 'Input file is not JSON; attempting to parse anyway',
-            });
-        }
-        return { files: [absolute], diagnostics };
-    }
-    diagnostics.push({
-        level: 'error',
-        code: 'path-not-supported',
-        message: `Path is neither a file nor directory: ${absolute}`,
-    });
-    return { files: [], diagnostics };
-}
-function isObjectLike(value) {
-    return typeof value === 'object' && value !== null;
-}
-function normalizeDiffContext(raw) {
-    if (!isObjectLike(raw)) {
-        return {
-            diagnostic: {
-                level: 'warning',
-                code: 'invalid-diff-context',
-                message: 'diff_context is present but malformed; skipping diff trend fields for this artifact',
-            },
-        };
-    }
-    const baseRef = typeof raw.baseRef === 'string' ? raw.baseRef : 'unknown';
-    const status = raw.status;
-    const scoreDelta = typeof raw.scoreDelta === 'number' && Number.isFinite(raw.scoreDelta) ? raw.scoreDelta : null;
-    const newIssues = typeof raw.newIssues === 'number' && Number.isFinite(raw.newIssues) ? raw.newIssues : null;
-    const resolvedIssues = typeof raw.resolvedIssues === 'number' && Number.isFinite(raw.resolvedIssues) ? raw.resolvedIssues : null;
-    const filesChanged = typeof raw.filesChanged === 'number' && Number.isFinite(raw.filesChanged) ? raw.filesChanged : 0;
-    const penalty = typeof raw.penalty === 'number' && Number.isFinite(raw.penalty) ? raw.penalty : 0;
-    const bonus = typeof raw.bonus === 'number' && Number.isFinite(raw.bonus) ? raw.bonus : 0;
-    const netImpact = typeof raw.netImpact === 'number' && Number.isFinite(raw.netImpact) ? raw.netImpact : 0;
-    if (scoreDelta == null || newIssues == null || resolvedIssues == null) {
-        return {
-            diagnostic: {
-                level: 'warning',
-                code: 'invalid-diff-context',
-                message: 'diff_context is missing numeric scoreDelta/newIssues/resolvedIssues; skipping diff trend fields for this artifact',
-            },
-        };
-    }
-    const normalizedStatus = status === 'improved' || status === 'regressed' || status === 'neutral'
-        ? status
-        : scoreDelta < 0
-            ? 'improved'
-            : scoreDelta > 0
-                ? 'regressed'
-                : 'neutral';
-    return {
-        diffContext: {
-            baseRef,
-            status: normalizedStatus,
-            scoreDelta,
-            newIssues,
-            resolvedIssues,
-            filesChanged,
-            penalty,
-            bonus,
-            netImpact,
-        },
-    };
-}
-function parseTrustArtifact(filePath) {
-    const diagnostics = [];
-    let rawContent = '';
-    try {
-        rawContent = readFileSync(filePath, 'utf8');
-    }
-    catch (error) {
-        diagnostics.push({
-            level: 'error',
-            code: 'read-failed',
-            file: filePath,
-            message: error instanceof Error ? error.message : String(error),
-        });
-        return { diagnostics };
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(rawContent);
-    }
-    catch (error) {
-        diagnostics.push({
-            level: 'error',
-            code: 'parse-failed',
-            file: filePath,
-            message: error instanceof Error ? error.message : String(error),
-        });
-        return { diagnostics };
-    }
-    if (!isObjectLike(parsed)) {
-        diagnostics.push({
-            level: 'error',
-            code: 'invalid-shape',
-            file: filePath,
-            message: 'Trust artifact must be a JSON object',
-        });
-        return { diagnostics };
-    }
-    const trustScore = parsed.trust_score;
-    if (typeof trustScore !== 'number' || !Number.isFinite(trustScore)) {
-        diagnostics.push({
-            level: 'error',
-            code: 'invalid-shape',
-            file: filePath,
-            message: 'Missing numeric trust_score',
-        });
-        return { diagnostics };
-    }
-    const mergeRisk = typeof parsed.merge_risk === 'string'
-        ? normalizeMergeRiskLevel(parsed.merge_risk)
-        : undefined;
-    if (!mergeRisk) {
-        diagnostics.push({
-            level: 'error',
-            code: 'invalid-shape',
-            file: filePath,
-            message: `Missing/invalid merge_risk (expected one of ${MERGE_RISK_ORDER.join(', ')})`,
-        });
-        return { diagnostics };
-    }
-    let diffContext;
-    if (parsed.diff_context !== undefined) {
-        const normalized = normalizeDiffContext(parsed.diff_context);
-        if (normalized.diagnostic) {
-            diagnostics.push({ ...normalized.diagnostic, file: filePath });
-        }
-        else {
-            diffContext = normalized.diffContext;
-        }
-    }
-    return {
-        record: {
-            filePath,
-            trustScore,
-            mergeRisk,
-            diffContext,
-        },
-        diagnostics,
-    };
-}
 function buildDiffTrend(records) {
     const withDiff = records.filter((record) => record.diffContext);
     if (withDiff.length === 0) {
@@ -325,6 +64,7 @@ function buildDiffTrend(records) {
         },
     };
 }
+const KPI_RATIO_DECIMALS = 4;
 export function computeTrustKpis(input, options) {
     const cwd = options?.cwd ?? process.cwd();
     const discovered = discoverTrustJsonFiles(input, cwd);
@@ -363,7 +103,7 @@ export function computeTrustKpis(input, options) {
             min: trustScores.length > 0 ? Math.min(...trustScores) : null,
             max: trustScores.length > 0 ? Math.max(...trustScores) : null,
         },
-        highRiskRatio: records.length > 0 ? round(highRiskCount / records.length, 4) : null,
+        highRiskRatio: records.length > 0 ? round(highRiskCount / records.length, KPI_RATIO_DECIMALS) : null,
         diffTrend: buildDiffTrend(records),
         diagnostics,
     };
@@ -437,7 +177,7 @@ export function computeTrustKpisFromReports(reports) {
             min: trustScores.length > 0 ? Math.min(...trustScores) : null,
             max: trustScores.length > 0 ? Math.max(...trustScores) : null,
         },
-        highRiskRatio: tempRecords.length > 0 ? round(highRiskCount / tempRecords.length, 4) : null,
+        highRiskRatio: tempRecords.length > 0 ? round(highRiskCount / tempRecords.length, KPI_RATIO_DECIMALS) : null,
         diffTrend: buildDiffTrend(tempRecords),
         diagnostics: [],
     };

package/dist/trust-policy.d.ts

@@ -0,0 +1,32 @@
+import type { DriftConfig, MergeRiskLevel } from './types.js';
+export interface TrustGateOptions {
+    enabled?: boolean;
+    minTrust?: number;
+    maxRisk?: MergeRiskLevel;
+}
+export interface TrustGatePolicyResolutionOptions {
+    branchName?: string;
+    policyPack?: string;
+    overrides?: TrustGateOptions;
+}
+export interface TrustGatePolicyResolutionStep {
+    source: 'base' | 'policy-pack' | 'branch-preset' | 'overrides';
+    name: string;
+    values: TrustGateOptions;
+}
+export interface TrustGatePolicyExplanation {
+    effectivePolicy: TrustGateOptions;
+    branchName?: string;
+    selectedPolicyPack?: string;
+    invalidPolicyPack?: string;
+    steps: TrustGatePolicyResolutionStep[];
+}
+export declare const MERGE_RISK_ORDER: MergeRiskLevel[];
+export declare function normalizeMergeRiskLevel(value: string): MergeRiskLevel | undefined;
+export declare function detectBranchName(env?: NodeJS.ProcessEnv): string | undefined;
+export declare function explainTrustGatePolicy(config: DriftConfig | undefined, branchName?: string, overrides?: TrustGateOptions): TrustGatePolicyExplanation;
+export declare function explainTrustGatePolicy(config: DriftConfig | undefined, options?: TrustGatePolicyResolutionOptions): TrustGatePolicyExplanation;
+export declare function resolveTrustGatePolicy(config: DriftConfig | undefined, branchName?: string, overrides?: TrustGateOptions): TrustGateOptions;
+export declare function resolveTrustGatePolicy(config: DriftConfig | undefined, options?: TrustGatePolicyResolutionOptions): TrustGateOptions;
+export declare function formatTrustGatePolicyExplanation(explanation: TrustGatePolicyExplanation): string;
+//# sourceMappingURL=trust-policy.d.ts.map

package/dist/trust-policy.js

@@ -0,0 +1,160 @@
+export const MERGE_RISK_ORDER = ['LOW', 'MEDIUM', 'HIGH', 'CRITICAL'];
+const BRANCH_ENV_CANDIDATES = [
+    'DRIFT_BRANCH',
+    'GITHUB_HEAD_REF',
+    'GITHUB_REF_NAME',
+    'CI_COMMIT_REF_NAME',
+    'BRANCH_NAME',
+];
+const PATTERN_EXACT_BOOST = 10_000;
+const PATTERN_STATIC_CHAR_WEIGHT = 10;
+function formatTrustGatePolicyValues(values) {
+    const enabled = typeof values.enabled === 'boolean' ? String(values.enabled) : 'inherit';
+    const minTrust = typeof values.minTrust === 'number' ? String(values.minTrust) : 'inherit';
+    const maxRisk = values.maxRisk ?? 'inherit';
+    return `enabled=${enabled} minTrust=${minTrust} maxRisk=${maxRisk}`;
+}
+export function normalizeMergeRiskLevel(value) {
+    const normalized = value.toUpperCase();
+    return MERGE_RISK_ORDER.find((level) => level === normalized);
+}
+function branchPatternToRegExp(pattern) {
+    const escaped = pattern.replace(/[|\\{}()[\]^$+?.]/g, '\\$&').replace(/\*/g, '.*');
+    return new RegExp(`^${escaped}$`);
+}
+function patternSpecificity(pattern) {
+    const wildcardCount = (pattern.match(/\*/g) ?? []).length;
+    const staticChars = pattern.replace(/\*/g, '').length;
+    const exactBoost = wildcardCount === 0 ? PATTERN_EXACT_BOOST : 0;
+    return exactBoost + staticChars * PATTERN_STATIC_CHAR_WEIGHT - wildcardCount;
+}
+function resolvePresetsForBranch(branchName, presets) {
+    if (!presets || presets.length === 0)
+        return [];
+    const matched = [];
+    for (let index = 0; index < presets.length; index += 1) {
+        const preset = presets[index];
+        if (!preset?.branch)
+            continue;
+        const regex = branchPatternToRegExp(preset.branch);
+        if (!regex.test(branchName))
+            continue;
+        matched.push({ preset, specificity: patternSpecificity(preset.branch), index });
+    }
+    matched.sort((a, b) => a.specificity - b.specificity || a.index - b.index);
+    return matched.map((entry) => entry.preset);
+}
+function normalizeMinTrust(value) {
+    return typeof value === 'number' && !Number.isNaN(value) ? value : undefined;
+}
+function normalizeMaxRisk(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    return normalizeMergeRiskLevel(value);
+}
+function normalizeTrustGateOptions(source) {
+    if (!source)
+        return {};
+    return {
+        enabled: typeof source.enabled === 'boolean' ? source.enabled : undefined,
+        minTrust: normalizeMinTrust(source.minTrust),
+        maxRisk: normalizeMaxRisk(source.maxRisk),
+    };
+}
+function mergeTrustGateOptions(base, layer) {
+    return {
+        enabled: typeof layer.enabled === 'boolean' ? layer.enabled : base.enabled,
+        minTrust: layer.minTrust ?? base.minTrust,
+        maxRisk: layer.maxRisk ?? base.maxRisk,
+    };
+}
+function normalizeResolutionOptions(branchNameOrOptions, explicitOverrides) {
+    if (typeof branchNameOrOptions === 'string') {
+        return {
+            branchName: branchNameOrOptions,
+            overrides: explicitOverrides,
+        };
+    }
+    if (!branchNameOrOptions) {
+        return { overrides: explicitOverrides };
+    }
+    return {
+        ...branchNameOrOptions,
+        overrides: explicitOverrides
+            ? mergeTrustGateOptions(normalizeTrustGateOptions(branchNameOrOptions.overrides), normalizeTrustGateOptions(explicitOverrides))
+            : branchNameOrOptions.overrides,
+    };
+}
+function resolvePolicyPack(policyPacks, policyPackName) {
+    const normalizedName = policyPackName?.trim();
+    if (!normalizedName)
+        return {};
+    if (!policyPacks)
+        return { name: normalizedName, invalid: normalizedName };
+    const pack = policyPacks[normalizedName];
+    if (!pack)
+        return { name: normalizedName, invalid: normalizedName };
+    return { name: normalizedName, pack };
+}
+export function detectBranchName(env = process.env) {
+    for (const key of BRANCH_ENV_CANDIDATES) {
+        const value = env[key]?.trim();
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+export function explainTrustGatePolicy(config, branchNameOrOptions, explicitOverrides) {
+    const policy = config?.trustGate;
+    const resolution = normalizeResolutionOptions(branchNameOrOptions, explicitOverrides);
+    const normalizedBranch = resolution.branchName?.trim();
+    const packResolution = resolvePolicyPack(policy?.policyPacks, resolution.policyPack);
+    const steps = [];
+    const base = normalizeTrustGateOptions(policy);
+    let effective = base;
+    steps.push({ source: 'base', name: 'trustGate', values: base });
+    if (packResolution.pack) {
+        const packOptions = normalizeTrustGateOptions(packResolution.pack);
+        effective = mergeTrustGateOptions(effective, packOptions);
+        steps.push({ source: 'policy-pack', name: packResolution.name ?? 'unknown', values: packOptions });
+    }
+    if (normalizedBranch) {
+        const matchedPresets = resolvePresetsForBranch(normalizedBranch, policy?.presets);
+        for (const preset of matchedPresets) {
+            const presetOptions = normalizeTrustGateOptions(preset);
+            effective = mergeTrustGateOptions(effective, presetOptions);
+            steps.push({ source: 'branch-preset', name: preset.branch, values: presetOptions });
+        }
+    }
+    const normalizedOverrides = normalizeTrustGateOptions(resolution.overrides);
+    if (Object.values(normalizedOverrides).some((value) => value !== undefined)) {
+        effective = mergeTrustGateOptions(effective, normalizedOverrides);
+        steps.push({ source: 'overrides', name: 'cli', values: normalizedOverrides });
+    }
+    return {
+        effectivePolicy: effective,
+        branchName: normalizedBranch,
+        selectedPolicyPack: packResolution.name,
+        invalidPolicyPack: packResolution.invalid,
+        steps,
+    };
+}
+export function resolveTrustGatePolicy(config, branchNameOrOptions, explicitOverrides) {
+    const options = normalizeResolutionOptions(branchNameOrOptions, explicitOverrides);
+    return explainTrustGatePolicy(config, options).effectivePolicy;
+}
+export function formatTrustGatePolicyExplanation(explanation) {
+    const lines = ['Trust gate policy resolution:'];
+    lines.push(`- branch: ${explanation.branchName ?? 'not provided'}`);
+    lines.push(`- policy pack: ${explanation.selectedPolicyPack ?? 'not selected'}`);
+    if (explanation.invalidPolicyPack) {
+        lines.push(`- invalid policy pack: ${explanation.invalidPolicyPack}`);
+    }
+    lines.push('- steps:');
+    for (const [index, step] of explanation.steps.entries()) {
+        lines.push(`  ${index + 1}. ${step.source} (${step.name}): ${formatTrustGatePolicyValues(step.values)}`);
+    }
+    lines.push(`- effective: ${formatTrustGatePolicyValues(explanation.effectivePolicy)}`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=trust-policy.js.map

package/dist/trust-render.d.ts

@@ -0,0 +1,9 @@
+import type { DriftTrustReport, TrustDiffContext, TrustFixPriority, TrustReason } from './types.js';
+export declare function renderTrustReasons(reasons: TrustReason[]): string;
+export declare function renderTrustPriorities(priorities: TrustFixPriority[]): string;
+export declare function renderTrustMarkdownReasons(reasons: TrustReason[]): string;
+export declare function renderTrustMarkdownPriorities(priorities: TrustFixPriority[]): string;
+export declare function renderTrustDiffBlock(diffContext: TrustDiffContext | undefined): string;
+export declare function renderTrustAdvancedComparison(advancedContext: DriftTrustReport['advanced_context']): string;
+export declare function renderTrustAdvancedGuidance(advancedContext: DriftTrustReport['advanced_context']): string;
+//# sourceMappingURL=trust-render.d.ts.map

package/dist/trust-render.js

@@ -0,0 +1,54 @@
+export function renderTrustReasons(reasons) {
+    if (reasons.length === 0)
+        return '- none';
+    return reasons.map((reason) => `- ${reason.label}: ${reason.detail} (impact ${reason.impact})`).join('\n');
+}
+export function renderTrustPriorities(priorities) {
+    if (priorities.length === 0)
+        return '- none';
+    return priorities
+        .map((priority) => `- #${priority.rank} ${priority.rule} (${priority.severity}, x${priority.occurrences}${priority.confidence ? `, confidence ${priority.confidence}` : ''}): ${priority.suggestion}`)
+        .join('\n');
+}
+export function renderTrustMarkdownReasons(reasons) {
+    if (reasons.length === 0)
+        return '- none';
+    return reasons.map((reason) => `- **${reason.label}**: ${reason.detail} (impact ${reason.impact})`).join('\n');
+}
+export function renderTrustMarkdownPriorities(priorities) {
+    if (priorities.length === 0)
+        return '- none';
+    return priorities
+        .map((priority) => `- #${priority.rank} \`${priority.rule}\` (${priority.severity}, x${priority.occurrences}, effort: ${priority.effort}${priority.confidence ? `, confidence: ${priority.confidence}` : ''}) - ${priority.suggestion}${priority.explanation ? ` ${priority.explanation}` : ''}`)
+        .join('\n');
+}
+export function renderTrustDiffBlock(diffContext) {
+    if (!diffContext) {
+        return [
+            '- Base ref: not provided',
+            '- Diff-aware adjustment: not applied',
+        ].join('\n');
+    }
+    return [
+        `- Base ref: \`${diffContext.baseRef}\``,
+        `- Diff status: **${diffContext.status.toUpperCase()}**`,
+        `- Score delta: **${diffContext.scoreDelta >= 0 ? '+' : ''}${diffContext.scoreDelta}**`,
+        `- Issues: **+${diffContext.newIssues}** new / **-${diffContext.resolvedIssues}** resolved`,
+        `- Trust adjustment: **+${diffContext.penalty}** penalty / **-${diffContext.bonus}** bonus (net ${diffContext.netImpact >= 0 ? '+' : ''}${diffContext.netImpact})`,
+    ].join('\n');
+}
+export function renderTrustAdvancedComparison(advancedContext) {
+    if (!advancedContext?.comparison)
+        return '- Historical comparison not available';
+    return [
+        `- Source: \`${advancedContext.comparison.source}\``,
+        `- Trend: **${advancedContext.comparison.trend.toUpperCase()}**`,
+        `- Summary: ${advancedContext.comparison.summary}`,
+    ].join('\n');
+}
+export function renderTrustAdvancedGuidance(advancedContext) {
+    if (!advancedContext?.team_guidance?.length)
+        return '- none';
+    return advancedContext.team_guidance.map((item) => `- ${item}`).join('\n');
+}
+//# sourceMappingURL=trust-render.js.map

package/dist/trust-scoring.d.ts

@@ -0,0 +1,9 @@
+import type { DriftDiff, DriftReport, MergeRiskLevel, TrustDiffContext, TrustFixPriority, TrustReason } from './types.js';
+export declare const TOP_REASONS_SLICE = 4;
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function toMergeRisk(trustScore: number): MergeRiskLevel;
+export declare function computeReasons(report: DriftReport): TrustReason[];
+export declare function computeDiffContext(diff: DriftDiff): TrustDiffContext;
+export declare function computeFixPriorities(report: DriftReport, advancedMode?: boolean): TrustFixPriority[];
+export declare function buildDiffRegressionReason(diffContext: TrustDiffContext): TrustReason;
+//# sourceMappingURL=trust-scoring.d.ts.map