@mergesignal/shared 0.2.2 → 0.2.3

package/dist/deriveCardOperationalObservations.js

@@ -0,0 +1,180 @@
+import { sortRecommendationsForDisplay } from "./actionsStepSummary.js";
+import { mapContributionToCatalogPhrase, mapExplainReasonToCatalogPhrase, mapFindingToCatalogPhrase, mapGraphInsightsToCatalogPhrases, mapRecommendationToCatalogPhrase, mapTextToCatalogPhrase, } from "./cardObservationCatalog.js";
+import { formatCardAreaLabels } from "./formatCardAreaLabels.js";
+import { selectTopAffectedAreas } from "./selectTopAffectedAreas.js";
+const SOURCE_WEIGHT = {
+    recommendation: 100,
+    explain: 80,
+    finding: 60,
+    graph: 50,
+    contribution: 45,
+    summary: 20,
+    area: 15,
+};
+let rankCounter = 0;
+function nextRank() {
+    rankCounter += 1;
+    return rankCounter;
+}
+function addCandidate(bucket, candidate) {
+    bucket.push({ ...candidate, rank: nextRank() });
+}
+function collectCandidates(result) {
+    const candidates = [];
+    rankCounter = 0;
+    const recs = sortRecommendationsForDisplay(Array.isArray(result.recommendations) ? result.recommendations : []);
+    for (const rec of recs) {
+        const mapped = mapRecommendationToCatalogPhrase(rec);
+        if (mapped) {
+            addCandidate(candidates, {
+                ...mapped,
+                weight: SOURCE_WEIGHT.recommendation,
+            });
+        }
+    }
+    if (Array.isArray(result.explain?.reasons)) {
+        const sorted = [...result.explain.reasons]
+            .filter((r) => r.title)
+            .sort((a, b) => Math.abs(b.scoreImpact ?? 0) - Math.abs(a.scoreImpact ?? 0));
+        for (const reason of sorted) {
+            const mapped = mapExplainReasonToCatalogPhrase(reason);
+            if (mapped) {
+                addCandidate(candidates, {
+                    ...mapped,
+                    weight: SOURCE_WEIGHT.explain,
+                });
+            }
+        }
+    }
+    if (Array.isArray(result.findings)) {
+        const severityOrder = { critical: 4, high: 3, medium: 2, low: 1 };
+        const sortedFindings = [...result.findings].sort((a, b) => (severityOrder[b.severity] ?? 0) - (severityOrder[a.severity] ?? 0));
+        for (const finding of sortedFindings) {
+            const mapped = mapFindingToCatalogPhrase(finding);
+            if (mapped) {
+                addCandidate(candidates, {
+                    ...mapped,
+                    weight: SOURCE_WEIGHT.finding,
+                });
+            }
+        }
+    }
+    for (const mapped of mapGraphInsightsToCatalogPhrases(result.graphInsights)) {
+        addCandidate(candidates, {
+            ...mapped,
+            weight: SOURCE_WEIGHT.graph,
+        });
+    }
+    if (Array.isArray(result.contributions)) {
+        for (const c of result.contributions) {
+            const mapped = mapContributionToCatalogPhrase(c.id);
+            if (mapped) {
+                addCandidate(candidates, {
+                    ...mapped,
+                    weight: SOURCE_WEIGHT.contribution,
+                });
+            }
+        }
+    }
+    const reasoning = result.decision?.reasoning;
+    if (Array.isArray(reasoning)) {
+        for (const line of reasoning) {
+            const mapped = mapTextToCatalogPhrase(line);
+            if (mapped) {
+                addCandidate(candidates, {
+                    ...mapped,
+                    weight: SOURCE_WEIGHT.summary,
+                });
+            }
+        }
+    }
+    if (Array.isArray(result.insights)) {
+        for (const ins of result.insights) {
+            const mapped = mapTextToCatalogPhrase(ins.message);
+            if (mapped) {
+                addCandidate(candidates, {
+                    ...mapped,
+                    weight: SOURCE_WEIGHT.summary,
+                });
+            }
+        }
+    }
+    return candidates;
+}
+function selectObservations(candidates, max) {
+    const byFamily = new Map();
+    for (const c of candidates) {
+        const existing = byFamily.get(c.family);
+        if (!existing || c.weight > existing.weight) {
+            byFamily.set(c.family, c);
+        }
+        else if (c.weight === existing.weight && c.rank < existing.rank) {
+            byFamily.set(c.family, c);
+        }
+    }
+    const distinct = [...byFamily.values()].sort((a, b) => {
+        if (b.weight !== a.weight)
+            return b.weight - a.weight;
+        return a.rank - b.rank;
+    });
+    if (distinct.length === 0)
+        return [];
+    const topWeight = distinct[0].weight;
+    const strongFamilies = distinct.filter((c) => c.weight >= topWeight - 15 || c.weight >= SOURCE_WEIGHT.finding);
+    let take = distinct;
+    if (strongFamilies.length <= 2 && distinct.length > 2) {
+        take = distinct.slice(0, 2);
+    }
+    else if (distinct.length > max) {
+        take = distinct.slice(0, max);
+    }
+    return take.map((c) => c.phrase);
+}
+function deriveSupportingLine(result, observations, candidates) {
+    if (observations.length !== 1)
+        return null;
+    const usedPhrase = observations[0];
+    const usedFamily = candidates.find((c) => c.phrase === usedPhrase)?.family;
+    const secondCatalog = candidates.find((c) => c.phrase !== usedPhrase && c.family !== usedFamily);
+    if (secondCatalog)
+        return secondCatalog.phrase;
+    const areas = formatCardAreaLabels(selectTopAffectedAreas(result, { max: 2 }));
+    const area = areas[0];
+    if (area && area.length <= 48 && !/\d/.test(area)) {
+        return area;
+    }
+    return null;
+}
+function denormalizedFallback(mergePosture) {
+    if (mergePosture === "safe") {
+        return { operationalObservations: [], supportingLine: null };
+    }
+    if (mergePosture === "needs_review") {
+        return { operationalObservations: [], supportingLine: null };
+    }
+    return { operationalObservations: [], supportingLine: null };
+}
+/**
+ * Derive 0–3 catalog-mapped operational observations for PR dashboard cards.
+ * Primary path: silence when no mappable signals (G2).
+ */
+export function deriveCardOperationalObservations(result, options) {
+    const max = options.max ?? 3;
+    const hasFullResult = options.hasFullResult !== false;
+    if (!result) {
+        if (hasFullResult) {
+            return { operationalObservations: [], supportingLine: null };
+        }
+        return denormalizedFallback(options.mergePosture);
+    }
+    const candidates = collectCandidates(result);
+    const operationalObservations = selectObservations(candidates, max);
+    if (operationalObservations.length === 0) {
+        if (hasFullResult) {
+            return { operationalObservations: [], supportingLine: null };
+        }
+        return denormalizedFallback(options.mergePosture);
+    }
+    const supportingLine = deriveSupportingLine(result, operationalObservations, candidates);
+    return { operationalObservations, supportingLine };
+}

package/dist/deriveCardOperationalObservations.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=deriveCardOperationalObservations.test.d.ts.map

package/dist/deriveCardOperationalObservations.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveCardOperationalObservations.test.d.ts","sourceRoot":"","sources":["../src/deriveCardOperationalObservations.test.ts"],"names":[],"mappings":""}

package/dist/deriveCardOperationalObservations.test.js

@@ -0,0 +1,268 @@
+import { describe, it, expect } from "vitest";
+import { CARD_OBSERVATION_CATALOG, containsImperativeOrActionLanguage, containsTelemetryOrDigits, isCatalogPhrase, isGenericObservation, mapRecommendationToCatalogPhrase, mapTextToCatalogPhrase, validateCatalogIntegrity, } from "./cardObservationCatalog.js";
+import { deriveCardOperationalObservations } from "./deriveCardOperationalObservations.js";
+const baseResult = {
+    totalScore: 10,
+    layerScores: {
+        security: 1,
+        maintainability: 2,
+        ecosystem: 3,
+        upgradeImpact: 4,
+    },
+    findings: [],
+    generatedAt: "2026-01-01T00:00:00.000Z",
+};
+describe("cardObservationCatalog", () => {
+    it("validates catalog integrity", () => {
+        expect(() => validateCatalogIntegrity()).not.toThrow();
+    });
+    it("keeps all catalog phrases within length and guardrails", () => {
+        for (const phrase of CARD_OBSERVATION_CATALOG) {
+            expect(isCatalogPhrase(phrase)).toBe(true);
+            expect(containsTelemetryOrDigits(phrase)).toBe(false);
+            expect(containsImperativeOrActionLanguage(phrase)).toBe(false);
+            expect(isGenericObservation(phrase)).toBe(false);
+            expect(phrase.length).toBeLessThanOrEqual(48);
+        }
+    });
+    it("maps recommendation imperatives to detection phrases", () => {
+        const mapped = mapRecommendationToCatalogPhrase({
+            id: "rec-1",
+            title: "Reduce duplicate dependency versions",
+            rationale: "Overlapping semver ranges on runtime boundary",
+            impact: "high",
+        });
+        expect(mapped?.phrase).toBe("Duplicate dependency versions detected");
+    });
+    it("maps graph.duplicates tokens to duplicate versions phrase", () => {
+        const mapped = mapTextToCatalogPhrase("graph.duplicates on runtime boundary");
+        expect(mapped?.phrase).toBe("Duplicate dependency versions detected");
+    });
+    it("rejects generic narration", () => {
+        expect(isGenericObservation("No high-confidence merge risks")).toBe(true);
+        expect(isGenericObservation("dependency concerns detected")).toBe(true);
+    });
+});
+describe("deriveCardOperationalObservations", () => {
+    it("returns silence on primary path when no mappable signals", () => {
+        const result = deriveCardOperationalObservations({
+            ...baseResult,
+            decision: {
+                recommendation: "safe",
+                confidence: "high",
+                reasoning: [
+                    "No high-confidence merge risks from this PR dependency change",
+                ],
+            },
+        }, { mergePosture: "safe", hasFullResult: true });
+        expect(result.operationalObservations).toEqual([]);
+        expect(result.supportingLine).toBeNull();
+    });
+    it("surfaces catalog phrase from explain.reasons instead of generic reasoning", () => {
+        const result = deriveCardOperationalObservations({
+            ...baseResult,
+            totalScore: 55,
+            decision: {
+                recommendation: "needs_review",
+                confidence: "medium",
+                reasoning: ["Potential runtime impact detected"],
+            },
+            explain: {
+                reasons: [
+                    {
+                        id: "graph.transitive.1",
+                        layer: "ecosystem",
+                        title: "graph.transitive volume cluster",
+                        scoreImpact: 18,
+                    },
+                ],
+            },
+        }, { mergePosture: "needs_review", hasFullResult: true });
+        expect(result.operationalObservations).toContain("High transitive dependency volume");
+        expect(result.operationalObservations.some((o) => /merge risk|runtime impact/i.test(o))).toBe(false);
+    });
+    it("maps duplicate signal from recommendation without leaking imperative title", () => {
+        const result = deriveCardOperationalObservations({
+            ...baseResult,
+            recommendations: [
+                {
+                    id: "rec-dup",
+                    title: "Reduce duplicate dependency versions",
+                    rationale: "Multiple semver majors on shared packages",
+                    impact: "high",
+                    priorityScore: 90,
+                },
+            ],
+        }, { mergePosture: "needs_review", hasFullResult: true });
+        expect(result.operationalObservations).toEqual([
+            "Duplicate dependency versions detected",
+        ]);
+        expect(result.operationalObservations.some((o) => /^reduce/i.test(o))).toBe(false);
+    });
+    it("caps at three distinct catalog phrases on fat scans", () => {
+        const fat = {
+            ...baseResult,
+            totalScore: 72,
+            recommendations: [
+                {
+                    id: "r1",
+                    title: "Reduce duplicate dependency versions",
+                    rationale: "semver overlap",
+                    impact: "high",
+                    priorityScore: 95,
+                },
+                {
+                    id: "r2",
+                    title: "Review transitive dependency surface",
+                    rationale: "graph.transitive volume",
+                    impact: "high",
+                    priorityScore: 90,
+                },
+            ],
+            explain: {
+                reasons: [
+                    {
+                        id: "g1",
+                        layer: "security",
+                        title: "graph.vulnerable packages",
+                        scoreImpact: 20,
+                    },
+                    {
+                        id: "g2",
+                        layer: "maintainability",
+                        title: "Stale releases on multiple direct dependencies",
+                        scoreImpact: 15,
+                    },
+                ],
+            },
+            graphInsights: {
+                maxDepth: 9,
+                nodes: 1500,
+                edges: 4000,
+                vulnerable: [
+                    {
+                        kind: "vulnerable",
+                        packageName: "lodash",
+                        direct: false,
+                        depth: 3,
+                    },
+                ],
+                hotspots: Array.from({ length: 5 }, (_, i) => ({
+                    kind: "hotspot",
+                    packageName: `pkg-${i}`,
+                    direct: true,
+                    depth: 1,
+                })),
+            },
+        };
+        const result = deriveCardOperationalObservations(fat, {
+            mergePosture: "risky",
+            hasFullResult: true,
+            max: 3,
+        });
+        expect(result.operationalObservations.length).toBeLessThanOrEqual(3);
+        for (const phrase of result.operationalObservations) {
+            expect(isCatalogPhrase(phrase)).toBe(true);
+            expect(containsTelemetryOrDigits(phrase)).toBe(false);
+            expect(containsImperativeOrActionLanguage(phrase)).toBe(false);
+        }
+        expect(result.supportingLine).toBeNull();
+    });
+    it("prefers one to two observations when one family dominates", () => {
+        const result = deriveCardOperationalObservations({
+            ...baseResult,
+            explain: {
+                reasons: [
+                    {
+                        id: "t1",
+                        layer: "ecosystem",
+                        title: "graph.transitive volume cluster 1",
+                        scoreImpact: 30,
+                    },
+                    {
+                        id: "t2",
+                        layer: "ecosystem",
+                        title: "graph.transitive volume cluster 2",
+                        scoreImpact: 25,
+                    },
+                    {
+                        id: "t3",
+                        layer: "ecosystem",
+                        title: "graph.transitive volume cluster 3",
+                        scoreImpact: 20,
+                    },
+                ],
+            },
+        }, { mergePosture: "needs_review", hasFullResult: true });
+        expect(result.operationalObservations).toEqual([
+            "High transitive dependency volume",
+        ]);
+    });
+    it("omits supporting line when three observations are shown", () => {
+        const result = deriveCardOperationalObservations({
+            ...baseResult,
+            recommendations: [
+                {
+                    id: "r1",
+                    title: "Reduce duplicate dependency versions",
+                    rationale: "dup",
+                    impact: "high",
+                    priorityScore: 95,
+                },
+            ],
+            explain: {
+                reasons: [
+                    {
+                        id: "e1",
+                        layer: "security",
+                        title: "graph.vulnerable",
+                        scoreImpact: 20,
+                    },
+                    {
+                        id: "e2",
+                        layer: "upgradeImpact",
+                        title: "Large upgrade blast radius",
+                        scoreImpact: 18,
+                    },
+                ],
+            },
+        }, { mergePosture: "risky", hasFullResult: true });
+        if (result.operationalObservations.length === 3) {
+            expect(result.supportingLine).toBeNull();
+        }
+    });
+    it("allows supporting line only with exactly one observation", () => {
+        const result = deriveCardOperationalObservations({
+            ...baseResult,
+            recommendations: [
+                {
+                    id: "r1",
+                    title: "Reduce duplicate dependency versions",
+                    rationale: "dup",
+                    impact: "high",
+                    priorityScore: 95,
+                },
+            ],
+            explain: {
+                reasons: [
+                    {
+                        id: "e1",
+                        layer: "security",
+                        title: "graph.vulnerable packages in tree",
+                        scoreImpact: 10,
+                    },
+                ],
+            },
+        }, { mergePosture: "needs_review", hasFullResult: true });
+        if (result.operationalObservations.length === 1) {
+            expect(result.supportingLine).toBe("Vulnerable transitive packages detected");
+        }
+    });
+    it("returns silence on denormalized path without signals", () => {
+        const result = deriveCardOperationalObservations(null, {
+            mergePosture: "safe",
+            hasFullResult: false,
+        });
+        expect(result.operationalObservations).toEqual([]);
+    });
+});

package/dist/formatCardAreaLabels.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Filter and rank area labels for dashboard cards (max 2).
+ * Longer specific labels win; generic taxonomy is dropped.
+ */
+export declare function formatCardAreaLabels(areas: string[] | null | undefined, max?: number): string[];
+/** Join formatted areas for evidence row display. */
+export declare function joinCardAreaLabels(areas: string[]): string | null;
+//# sourceMappingURL=formatCardAreaLabels.d.ts.map

package/dist/formatCardAreaLabels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatCardAreaLabels.d.ts","sourceRoot":"","sources":["../src/formatCardAreaLabels.ts"],"names":[],"mappings":"AAmCA;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,EAClC,GAAG,SAAI,GACN,MAAM,EAAE,CAmBV;AAED,qDAAqD;AACrD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,CAIjE"}

package/dist/formatCardAreaLabels.js

@@ -0,0 +1,65 @@
+import { GENERIC_CARD_AREA_PHRASES } from "./cardSummaryCopy.js";
+const PATH_LIKE = /[/\\]|^packages\/|\.tsx?$|\.jsx?$|^src\//i;
+const KEBAB_SNAKE = /^[a-z0-9]+[-_][a-z0-9_-]+$/;
+function normalizeKey(label) {
+    return label.trim().toLowerCase();
+}
+function isTechnicalLabel(label) {
+    const t = label.trim();
+    if (!t)
+        return true;
+    if (PATH_LIKE.test(t))
+        return true;
+    if (KEBAB_SNAKE.test(t) && !/\s/.test(t))
+        return true;
+    return false;
+}
+function isGenericArea(label) {
+    const key = normalizeKey(label);
+    return GENERIC_CARD_AREA_PHRASES.some((g) => key === g || key.startsWith(`${g} `) || key.endsWith(` ${g}`));
+}
+function humanizeLabel(label) {
+    const clean = label.replace(/^(Finding:\s*|Area:\s*)/i, "").trim();
+    if (!clean)
+        return "";
+    if (/\s/.test(clean) || /^[A-Z]/.test(clean))
+        return clean;
+    return clean
+        .split(/[-_]/)
+        .filter(Boolean)
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+        .join(" ");
+}
+/**
+ * Filter and rank area labels for dashboard cards (max 2).
+ * Longer specific labels win; generic taxonomy is dropped.
+ */
+export function formatCardAreaLabels(areas, max = 2) {
+    if (!Array.isArray(areas) || areas.length === 0)
+        return [];
+    const seen = new Set();
+    const candidates = [];
+    for (const raw of areas) {
+        if (isTechnicalLabel(raw))
+            continue;
+        const label = humanizeLabel(raw);
+        if (!label || label.length < 4)
+            continue;
+        if (isGenericArea(label))
+            continue;
+        const key = normalizeKey(label);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        candidates.push(label);
+    }
+    candidates.sort((a, b) => b.length - a.length);
+    return candidates.slice(0, max);
+}
+/** Join formatted areas for evidence row display. */
+export function joinCardAreaLabels(areas) {
+    const formatted = formatCardAreaLabels(areas);
+    if (formatted.length === 0)
+        return null;
+    return formatted.join(" · ");
+}

package/dist/formatCardEvidenceCounts.d.ts

@@ -0,0 +1,7 @@
+import type { FindingCountSummary } from "./scanCardSummary.js";
+import type { MergePosture } from "./riskVocabulary.js";
+/**
+ * One soft evidence phrase for dashboard cards (not scanner-style metrics).
+ */
+export declare function formatCardEvidenceCounts(counts: FindingCountSummary | null | undefined, posture: MergePosture | null): string | null;
+//# sourceMappingURL=formatCardEvidenceCounts.d.ts.map

package/dist/formatCardEvidenceCounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatCardEvidenceCounts.d.ts","sourceRoot":"","sources":["../src/formatCardEvidenceCounts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,mBAAmB,GAAG,IAAI,GAAG,SAAS,EAC9C,OAAO,EAAE,YAAY,GAAG,IAAI,GAC3B,MAAM,GAAG,IAAI,CAaf"}

package/dist/formatCardEvidenceCounts.js

@@ -0,0 +1,19 @@
+/**
+ * One soft evidence phrase for dashboard cards (not scanner-style metrics).
+ */
+export function formatCardEvidenceCounts(counts, posture) {
+    if (!counts || !posture || posture === "safe")
+        return null;
+    const { critical, high } = counts;
+    if (critical > 0 && posture === "risky") {
+        if (critical === 1)
+            return "1 critical finding";
+        return "Critical findings present";
+    }
+    if (high > 0 && (posture === "risky" || posture === "needs_review")) {
+        if (high === 1)
+            return "1 high-severity finding";
+        return `${high} high-severity findings`;
+    }
+    return null;
+}

package/dist/formatCardExposureDisplay.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Dashboard card exposure semantics — display-only interpretation of totalScore.
+ * Not persisted; not an engine output; complements merge posture (Safe / Review / Risky).
+ */
+export type CardExposureCategory = "minimal" | "limited" | "moderate" | "elevated" | "broad";
+export type CardExposureDisplay = {
+    category: CardExposureCategory;
+    /** User-facing label, e.g. "Moderate exposure". */
+    label: string;
+    value: number;
+};
+/** User-facing exposure labels for docs and UI copy (low → high). */
+export declare const CARD_EXPOSURE_CATEGORY_LABELS: readonly string[];
+/** Map numeric totalScore to a fixed exposure category (card UX only). */
+export declare function deriveCardExposureDisplay(score: number | null | undefined): CardExposureDisplay | null;
+/** Compact card line: exposure category label only. */
+export declare function formatCardExposureLine(score: number | null | undefined): string | null;
+/** Fragment for composite aria labels on PR cards. */
+export declare function exposureAriaFragment(score: number | null | undefined): string | null;
+//# sourceMappingURL=formatCardExposureDisplay.d.ts.map

package/dist/formatCardExposureDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatCardExposureDisplay.d.ts","sourceRoot":"","sources":["../src/formatCardExposureDisplay.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,oBAAoB,GAC5B,SAAS,GACT,SAAS,GACT,UAAU,GACV,UAAU,GACV,OAAO,CAAC;AAEZ,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAUF,qEAAqE;AACrE,eAAO,MAAM,6BAA6B,EAAE,SAAS,MAAM,EAM1D,CAAC;AAkBF,0EAA0E;AAC1E,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/B,mBAAmB,GAAG,IAAI,CAM5B;AAED,uDAAuD;AACvD,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/B,MAAM,GAAG,IAAI,CAIf;AAED,sDAAsD;AACtD,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/B,MAAM,GAAG,IAAI,CAIf"}

package/dist/formatCardExposureDisplay.js

@@ -0,0 +1,56 @@
+/**
+ * Dashboard card exposure semantics — display-only interpretation of totalScore.
+ * Not persisted; not an engine output; complements merge posture (Safe / Review / Risky).
+ */
+const EXPOSURE_LABEL = {
+    minimal: "Minimal exposure",
+    limited: "Limited exposure",
+    moderate: "Moderate exposure",
+    elevated: "Elevated exposure",
+    broad: "Broad exposure",
+};
+/** User-facing exposure labels for docs and UI copy (low → high). */
+export const CARD_EXPOSURE_CATEGORY_LABELS = [
+    EXPOSURE_LABEL.minimal,
+    EXPOSURE_LABEL.limited,
+    EXPOSURE_LABEL.moderate,
+    EXPOSURE_LABEL.elevated,
+    EXPOSURE_LABEL.broad,
+];
+/** Inclusive upper bounds (0–100). Five stable buckets only. */
+const EXPOSURE_UPPER_BOUND = [24, 44, 74, 89, 100];
+const EXPOSURE_ORDER = [
+    "minimal",
+    "limited",
+    "moderate",
+    "elevated",
+    "broad",
+];
+function clampScore(score) {
+    if (!Number.isFinite(score))
+        return 0;
+    return Math.min(100, Math.max(0, Math.round(score)));
+}
+/** Map numeric totalScore to a fixed exposure category (card UX only). */
+export function deriveCardExposureDisplay(score) {
+    if (score == null || !Number.isFinite(score))
+        return null;
+    const value = clampScore(score);
+    const idx = EXPOSURE_UPPER_BOUND.findIndex((bound) => value <= bound);
+    const category = EXPOSURE_ORDER[idx >= 0 ? idx : EXPOSURE_ORDER.length - 1];
+    return { category, label: EXPOSURE_LABEL[category], value };
+}
+/** Compact card line: exposure category label only. */
+export function formatCardExposureLine(score) {
+    const display = deriveCardExposureDisplay(score);
+    if (!display)
+        return null;
+    return display.label;
+}
+/** Fragment for composite aria labels on PR cards. */
+export function exposureAriaFragment(score) {
+    const display = deriveCardExposureDisplay(score);
+    if (!display)
+        return null;
+    return display.label;
+}

package/dist/formatCardExposureDisplay.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=formatCardExposureDisplay.test.d.ts.map

package/dist/formatCardExposureDisplay.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatCardExposureDisplay.test.d.ts","sourceRoot":"","sources":["../src/formatCardExposureDisplay.test.ts"],"names":[],"mappings":""}